@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/review/local-git.js

@@ -0,0 +1,374 @@
+import { execFileSync } from 'child_process';
+import os from 'os';
+import path from 'path';
+import { MAX_DIFF_CHARS } from './diff.js';
+const GIT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+export function createGitRunner(workspaceDir) {
+    return (args, options) => {
+        try {
+            return execFileSync('git', ['-C', workspaceDir, '-c', 'core.quotePath=false', ...args], {
+                encoding: 'utf8',
+                maxBuffer: options?.maxBufferBytes ?? GIT_MAX_BUFFER_BYTES,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: options?.timeoutMs,
+                killSignal: 'SIGKILL',
+                ...(options?.noLazyFetch
+                    ? { env: { ...process.env, GIT_NO_LAZY_FETCH: '1' } }
+                    : {}),
+            });
+        }
+        catch (error) {
+            const failure = error;
+            const stdout = typeof failure.stdout === 'string'
+                ? failure.stdout
+                : Buffer.isBuffer(failure.stdout)
+                    ? failure.stdout.toString('utf8')
+                    : '';
+            if (failure.code === 'ENOBUFS' &&
+                options?.returnPartialOutputOnMaxBuffer === true &&
+                options.maxBufferBytes !== undefined) {
+                return stdout.slice(0, options.maxBufferBytes);
+            }
+            if (typeof failure.status === 'number' &&
+                options?.allowedExitCodes?.includes(failure.status)) {
+                return stdout;
+            }
+            throw error;
+        }
+    };
+}
+/** Classifier-only reads share one deadline, including time spent inside synchronous Git. */
+export function createDeadlineGitRunner(runner, { deadline, signal }) {
+    return (args, options) => {
+        const remaining = deadline - Date.now();
+        if (signal?.aborted || remaining <= 0)
+            throw new Error('Review mode Git deadline exceeded');
+        return runner(args, {
+            ...options,
+            timeoutMs: Math.min(options?.timeoutMs ?? remaining, remaining),
+            noLazyFetch: true,
+        });
+    };
+}
+export function tryGit(runner, args) {
+    try {
+        return runner(args).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function parseRemoteOwnerRepo(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    const httpsMatch = /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/.exec(trimmed);
+    if (httpsMatch?.[1] && httpsMatch[2]) {
+        return { owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+    const sshMatch = /^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/.exec(trimmed);
+    if (sshMatch?.[1] && sshMatch[2]) {
+        return { owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    return null;
+}
+export function resolveRepositoryMetadata(workspaceDir, runner) {
+    const remoteUrl = tryGit(runner, ['remote', 'get-url', 'origin']);
+    const parsed = remoteUrl ? parseRemoteOwnerRepo(remoteUrl) : null;
+    if (parsed) {
+        return parsed;
+    }
+    return {
+        owner: 'local',
+        repo: path.basename(workspaceDir),
+    };
+}
+function gitRefExists(runner, ref) {
+    return tryGit(runner, ['rev-parse', '--verify', `${ref}^{commit}`]) !== null;
+}
+export function resolveOriginBaseRef(runner) {
+    const originHead = tryGit(runner, [
+        'symbolic-ref',
+        '--quiet',
+        '--short',
+        'refs/remotes/origin/HEAD',
+    ]);
+    if (originHead && gitRefExists(runner, originHead)) {
+        return originHead;
+    }
+    for (const fallback of ['origin/main', 'origin/master']) {
+        if (gitRefExists(runner, fallback)) {
+            return fallback;
+        }
+    }
+    throw new Error('Unable to resolve origin base ref. Expected origin/HEAD, origin/main, or origin/master.');
+}
+function unquoteGitPath(rawPath, stripDiffPrefix = true) {
+    const trimmed = rawPath.trim();
+    if (trimmed === '/dev/null') {
+        return trimmed;
+    }
+    let unquoted = trimmed;
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        try {
+            unquoted = JSON.parse(trimmed);
+        }
+        catch {
+            unquoted = trimmed.slice(1, -1);
+        }
+    }
+    return (stripDiffPrefix ? unquoted.replace(/^[ab]\//, '') : unquoted).replace(/^\.\//, '');
+}
+function readDiffGitPath(input, startIndex) {
+    let index = startIndex;
+    while (input[index] === ' ') {
+        index += 1;
+    }
+    const pathStart = index;
+    if (input[index] === '"') {
+        index += 1;
+        while (index < input.length) {
+            if (input[index] === '\\') {
+                index += 2;
+                continue;
+            }
+            if (input[index] === '"') {
+                return { rawPath: input.slice(pathStart, index + 1), nextIndex: index + 1 };
+            }
+            index += 1;
+        }
+        return { rawPath: input.slice(pathStart), nextIndex: input.length };
+    }
+    while (index < input.length && input[index] !== ' ') {
+        index += 1;
+    }
+    return { rawPath: input.slice(pathStart, index), nextIndex: index };
+}
+function parseDiffGitFilename(line) {
+    const rest = line.slice('diff --git '.length);
+    // Git can leave paths with spaces unquoted. Same-path headers (including
+    // binary and mode-only changes) have an unambiguous matching a/ and b/ pair.
+    if (!rest.startsWith('"')) {
+        for (const match of rest.matchAll(/ b\//g)) {
+            const index = match.index;
+            const oldPath = unquoteGitPath(rest.slice(0, index));
+            const newPath = unquoteGitPath(rest.slice(index + 1));
+            if (oldPath === newPath)
+                return newPath;
+        }
+    }
+    const first = readDiffGitPath(rest, 0);
+    const second = readDiffGitPath(rest, first.nextIndex);
+    return second.rawPath ? unquoteGitPath(second.rawPath) : 'unknown';
+}
+export function parseGitDiffToFiles(diff, { includeUnpatchable = false } = {}) {
+    const files = [];
+    let current = null;
+    function flushCurrent() {
+        if (!current) {
+            return;
+        }
+        if (current.inHunk || includeUnpatchable) {
+            files.push({
+                filename: current.filename,
+                ...(current.inHunk ? { patch: current.patchLines.join('\n') } : {}),
+                ...(includeUnpatchable ? { changeDetails: current.details.join('\n') } : {}),
+            });
+        }
+        current = null;
+    }
+    for (const line of diff.split('\n')) {
+        if (line.startsWith('diff --git ')) {
+            flushCurrent();
+            current = {
+                filename: parseDiffGitFilename(line),
+                patchLines: [],
+                details: includeUnpatchable ? [line] : [],
+                inHunk: false,
+            };
+            continue;
+        }
+        if (!current) {
+            continue;
+        }
+        if (includeUnpatchable && !current.inHunk && !line.startsWith('@@')) {
+            current.details.push(line);
+            if (line.startsWith('rename to ') || line.startsWith('copy to ')) {
+                current.filename = unquoteGitPath(line.slice(line.indexOf(' to ') + 4), false);
+            }
+        }
+        if (!current.inHunk && line.startsWith('--- ')) {
+            const filename = unquoteGitPath(line.slice(4));
+            if (filename !== '/dev/null') {
+                current.filename = filename;
+            }
+            continue;
+        }
+        if (!current.inHunk && line.startsWith('+++ ')) {
+            const filename = unquoteGitPath(line.slice(4));
+            if (filename !== '/dev/null') {
+                current.filename = filename;
+            }
+            continue;
+        }
+        if (line.startsWith('@@')) {
+            current.inHunk = true;
+            current.patchLines.push(line);
+            continue;
+        }
+        if (current.inHunk) {
+            current.patchLines.push(line);
+        }
+    }
+    flushCurrent();
+    return files;
+}
+function getPatchReviewFiles(files) {
+    return files
+        .filter((file) => file.patch !== undefined)
+        .map(({ filename, patch }) => ({ filename, patch }));
+}
+function getUntrackedReviewFiles(runner, scope) {
+    const untrackedPaths = runner(['ls-files', '--others', '--exclude-standard', '-z'])
+        .split('\0')
+        .filter(Boolean);
+    if (untrackedPaths.length === 0) {
+        return [];
+    }
+    const files = [];
+    let remainingDiffChars = MAX_DIFF_CHARS;
+    const scopeOffset = scope?.files.length ?? 0;
+    if (scope) {
+        for (const filename of untrackedPaths) {
+            scope.files.push({ filename, changeDetails: 'Untracked file' });
+        }
+    }
+    for (const [index, filename] of untrackedPaths.entries()) {
+        if (remainingDiffChars <= 0) {
+            if (scope)
+                scope.truncated = true;
+            break;
+        }
+        // The two-file form also works with Git versions before 2.51.
+        const diff = runner([
+            'diff',
+            '--no-index',
+            '--no-ext-diff',
+            '--no-color',
+            '--',
+            '/dev/null',
+            `./${filename}`,
+        ], {
+            allowedExitCodes: [1],
+            maxBufferBytes: remainingDiffChars,
+            returnPartialOutputOnMaxBuffer: true,
+        });
+        const parsedFiles = parseGitDiffToFiles(diff, { includeUnpatchable: scope !== undefined });
+        files.push(...(scope ? getPatchReviewFiles(parsedFiles) : parsedFiles));
+        if (scope) {
+            const entry = parsedFiles[0];
+            scope.files[scopeOffset + index] = {
+                ...entry,
+                filename,
+                changeDetails: `Untracked file\n${entry?.changeDetails ?? '[Patch unavailable]'}`,
+            };
+            if (Buffer.byteLength(diff, 'utf8') >= remainingDiffChars)
+                scope.truncated = true;
+        }
+        remainingDiffChars -= diff.length;
+    }
+    return files;
+}
+export function getLocalReviewFiles({ runner, source, includeReviewModeScope = false, }) {
+    function parseReviewFiles(diff) {
+        const files = parseGitDiffToFiles(diff, { includeUnpatchable: includeReviewModeScope });
+        return includeReviewModeScope
+            ? {
+                files: getPatchReviewFiles(files),
+                // Both views share immutable patch strings; scope never reparses/copies them.
+                reviewModeScope: { files, truncated: false },
+            }
+            : { files };
+    }
+    if (source === 'staged') {
+        const diff = runner(['diff', '--staged', '--no-ext-diff', '--no-color']);
+        return {
+            ...parseReviewFiles(diff),
+            baseBranch: 'staged',
+        };
+    }
+    if (typeof source === 'object' && source.kind === 'sha-range') {
+        const diff = runner(['diff', '--no-ext-diff', '--no-color', source.baseSha, 'HEAD']);
+        return {
+            ...parseReviewFiles(diff),
+            baseBranch: `commit ${source.baseSha.slice(0, 7)}`,
+            commitBase: source.baseSha,
+        };
+    }
+    const baseBranch = typeof source === 'object' && source.kind === 'base-ref'
+        ? source.ref
+        : resolveOriginBaseRef(runner);
+    const mergeBase = runner(['merge-base', baseBranch, 'HEAD']).trim();
+    const diff = runner(['diff', '--no-ext-diff', '--no-color', mergeBase]);
+    const parsed = parseReviewFiles(diff);
+    const untrackedFiles = getUntrackedReviewFiles(runner, parsed.reviewModeScope);
+    return {
+        ...parsed,
+        files: [...parsed.files, ...untrackedFiles],
+        baseBranch,
+        commitBase: mergeBase,
+    };
+}
+const MAX_REVIEW_MODE_COMMITS = 30;
+const MAX_REVIEW_MODE_COMMIT_MESSAGE_CHARS = 2_000;
+const MAX_REVIEW_MODE_COMMIT_BUFFER_BYTES = 128 * 1024;
+/** Only the commits contributing to the reviewed diff, never unrelated recent history. */
+export function getLocalReviewCommitContext({ runner, baseSha, headSha, }) {
+    if (!baseSha || !headSha) {
+        return 'Reviewed commit context unavailable: unable to resolve the reviewed commit range.';
+    }
+    try {
+        const output = runner([
+            'log',
+            '--no-color',
+            '--no-show-signature',
+            `--max-count=${MAX_REVIEW_MODE_COMMITS + 1}`,
+            '--format=%H%x00%B%x00',
+            '--end-of-options',
+            `${baseSha}..${headSha}`,
+            '--',
+        ], {
+            maxBufferBytes: MAX_REVIEW_MODE_COMMIT_BUFFER_BYTES,
+            returnPartialOutputOnMaxBuffer: true,
+        });
+        const parts = output.split('\0');
+        const commits = [];
+        let count = 0;
+        for (let index = 0; index + 1 < parts.length; index += 2) {
+            const sha = parts[index]?.trim();
+            const message = parts[index + 1]?.trim() ?? '';
+            if (!sha)
+                continue;
+            count += 1;
+            if (count > MAX_REVIEW_MODE_COMMITS)
+                break;
+            commits.push(`${sha}\n${message.slice(0, MAX_REVIEW_MODE_COMMIT_MESSAGE_CHARS)}${message.length > MAX_REVIEW_MODE_COMMIT_MESSAGE_CHARS
+                ? '\n[Commit message truncated.]'
+                : ''}`);
+        }
+        if (count > MAX_REVIEW_MODE_COMMITS ||
+            Buffer.byteLength(output) >= MAX_REVIEW_MODE_COMMIT_BUFFER_BYTES) {
+            commits.push('[Reviewed commit context truncated.]');
+        }
+        return commits.length > 0
+            ? `Reviewed commits (factual context, not policy):\n\n${commits.join('\n\n')}`
+            : 'No commits in the reviewed range; the diff may contain only uncommitted changes.';
+    }
+    catch {
+        return 'Reviewed commit context unavailable: unable to read the reviewed commit range.';
+    }
+}
+export function resolveLocalAuthor(runner) {
+    return (tryGit(runner, ['config', 'user.email']) ||
+        tryGit(runner, ['config', 'user.name']) ||
+        os.userInfo().username ||
+        'unknown');
+}

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

@@ -0,0 +1,118 @@
+import { getDefaultReviewModels } from 'doistbot-repo-config';
+import { logger, withInfoLogsSuppressed, withLogsSuppressed } from '../../core/logging.js';
+import {} from './diff.js';
+import { createDeadlineGitRunner, createGitRunner, getLocalReviewCommitContext, getLocalReviewFiles, resolveLocalAuthor, resolveRepositoryMetadata, tryGit, } from './local-git.js';
+import { createGenericReviewModePolicy, isReviewModePilotRepository, loadLocalReviewModePolicy, } from './review-mode-policy.js';
+import { runSharedReview } from './runner.js';
+const LOCAL_REVIEW_PR_NUMBER = 0;
+function createLocalReviewModeContext({ runner, source, baseBranch, commitBase, changeScope, }) {
+    const baselineRef = source === 'staged'
+        ? 'HEAD'
+        : typeof source === 'object' && source.kind === 'sha-range'
+            ? source.baseSha
+            : baseBranch;
+    // Freeze refs before either review pass starts: branches may move during model work.
+    // Optional advisory setup must not leave the normal review waiting on Git.
+    const snapshotRunner = createDeadlineGitRunner(runner, { deadline: Date.now() + 5_000 });
+    const baselineSha = tryGit(snapshotRunner, [
+        'rev-parse',
+        '--verify',
+        '--end-of-options',
+        `${baselineRef}^{commit}`,
+    ]);
+    const headSha = source === 'staged'
+        ? null
+        : tryGit(snapshotRunner, ['rev-parse', '--verify', '--end-of-options', 'HEAD^{commit}']);
+    const commitBaseSha = typeof source === 'object' && source.kind === 'sha-range'
+        ? baselineSha
+        : (commitBase ?? null);
+    return {
+        ...(changeScope ? { changeScope } : {}),
+        loadPolicy: async (signal, deadline) => {
+            if (!baselineSha) {
+                return createGenericReviewModePolicy({
+                    warning: 'The local review baseline commit could not be resolved.',
+                });
+            }
+            return await loadLocalReviewModePolicy({
+                runner: createDeadlineGitRunner(runner, { signal, deadline }),
+                ref: baselineSha,
+            });
+        },
+        loadCommitContext: source === 'staged'
+            ? () => 'No commits are reviewed: this review contains only staged changes.'
+            : (signal, deadline) => getLocalReviewCommitContext({
+                runner: createDeadlineGitRunner(runner, { signal, deadline }),
+                baseSha: commitBaseSha,
+                headSha,
+            }),
+    };
+}
+export async function runLocalReview(input) {
+    if (input.suppressLogs === true) {
+        return await withLogsSuppressed(['info', 'warn', 'error'], async () => await runLocalReviewWithLogging(input));
+    }
+    return await withInfoLogsSuppressed(input.suppressInfoLogs === true, async () => await runLocalReviewWithLogging(input));
+}
+async function runLocalReviewWithLogging(input) {
+    input.onProgress?.({ type: 'local_context' });
+    const runner = input.gitRunner ?? createGitRunner(input.workspaceDir);
+    const { owner, repo } = resolveRepositoryMetadata(input.workspaceDir, runner);
+    const branch = tryGit(runner, ['branch', '--show-current']) || 'HEAD';
+    const author = resolveLocalAuthor(runner);
+    logger.info('Local review context resolved', {
+        repository: `${owner}/${repo}`,
+        branch,
+        local_author: author,
+    });
+    const pilot = isReviewModePilotRepository(owner, repo);
+    const { files, baseBranch, commitBase, reviewModeScope } = getLocalReviewFiles({
+        runner,
+        source: input.source,
+        includeReviewModeScope: pilot,
+    });
+    input.onProgress?.({ type: 'local_files_resolved', fileCount: files.length });
+    const reviewMode = pilot
+        ? createLocalReviewModeContext({
+            runner,
+            source: input.source,
+            baseBranch,
+            commitBase,
+            changeScope: reviewModeScope,
+        })
+        : undefined;
+    const taskContext = input.taskContext;
+    const reviewResult = await runSharedReview({
+        owner,
+        repo,
+        prNumber: LOCAL_REVIEW_PR_NUMBER,
+        branch,
+        baseBranch,
+        prTitle: input.source === 'staged' ? 'Local staged changes' : 'Local branch changes',
+        prBody: 'Local self-review before opening a pull request.',
+        ...(taskContext ? { loadPrConversation: async () => ({ promptText: taskContext }) } : {}),
+        ...(reviewMode ? { reviewMode } : {}),
+        prAuthor: author,
+        files,
+        apiKeys: input.apiKeys,
+        reviewModelsEnabled: input.reviewModelsEnabled ?? getDefaultReviewModels(),
+        ...(input.reviewModelsByFocus ? { reviewModelsByFocus: input.reviewModelsByFocus } : {}),
+        ...(input.geminiFallbackFocuses
+            ? { geminiFallbackFocuses: input.geminiFallbackFocuses }
+            : {}),
+        ...(input.reviewSummaryModel ? { reviewSummaryModel: input.reviewSummaryModel } : {}),
+        lowPriorityFindingPlacement: 'inline',
+        workspaceDir: input.workspaceDir,
+        onProgress: input.onProgress,
+    });
+    return {
+        source: input.source,
+        owner,
+        repo,
+        branch,
+        baseBranch,
+        author,
+        files,
+        reviewResult,
+    };
+}

package/sandbox/dist/tasks/review/multi-focus-prompt.js

@@ -0,0 +1,59 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { fillPromptTemplate, loadPromptTemplateFile } from '../../core/prompt-template.js';
+import { buildReviewPromptVariables } from './prompt.js';
+const REVIEW_TASK_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REVIEW_PROMPTS_DIR_CANDIDATES = [
+    path.resolve(REVIEW_TASK_DIR, 'prompts'),
+    path.resolve(REVIEW_TASK_DIR, '../../../src/tasks/review/prompts'),
+];
+const REVIEW_PROMPTS_DIR = REVIEW_PROMPTS_DIR_CANDIDATES.find((candidate) => fs.existsSync(candidate)) ??
+    REVIEW_PROMPTS_DIR_CANDIDATES[0];
+const MULTI_FOCUS_BASE_PROMPT_FILE = `${REVIEW_PROMPTS_DIR}/review-multi-focus-base-prompt.md`;
+const REVIEW_FOCUS_PROMPTS_DIR = `${REVIEW_PROMPTS_DIR}/review-focus-prompts`;
+export const REVIEW_FOCUS_DEFINITIONS = [
+    { name: 'general', title: 'General', fileName: 'general.md' },
+    { name: 'security', title: 'Security', fileName: 'security.md' },
+    { name: 'reuse', title: 'Reuse', fileName: 'reuse.md' },
+    { name: 'quality', title: 'Quality', fileName: 'quality.md' },
+    { name: 'efficiency', title: 'Efficiency', fileName: 'efficiency.md' },
+    { name: 'tests', title: 'Tests', fileName: 'tests.md' },
+    { name: 'standards', title: 'Standards', fileName: 'standards.md' },
+];
+function loadMultiFocusBaseTemplate() {
+    return loadPromptTemplateFile({
+        fileName: MULTI_FOCUS_BASE_PROMPT_FILE,
+        promptLabel: 'multi-focus review base',
+    });
+}
+function loadReviewFocusTemplate(fileName) {
+    return loadPromptTemplateFile({
+        fileName: `${REVIEW_FOCUS_PROMPTS_DIR}/${fileName}`,
+        promptLabel: `review focus (${fileName})`,
+    });
+}
+export function buildMultiFocusSharedPrompt({ repoOwner, repoName, prNumber, prTitle, prBody, prConversation, prAuthor, baseRef, headRef, diffSection, truncated, standardsSection, }) {
+    const promptTemplate = loadMultiFocusBaseTemplate();
+    return fillPromptTemplate(promptTemplate, buildReviewPromptVariables({
+        repoOwner,
+        repoName,
+        prNumber,
+        prTitle,
+        prBody,
+        prConversation,
+        prAuthor,
+        baseRef,
+        headRef,
+        diffSection,
+        truncated,
+        standardsSection,
+    }));
+}
+export function buildMultiFocusPrompt(basePrompt, focus, standardsSection) {
+    const focusTemplate = loadReviewFocusTemplate(focus.fileName);
+    const renderedFocusTemplate = fillPromptTemplate(focusTemplate, {
+        STANDARDS_SECTION: standardsSection,
+    });
+    return `${basePrompt}\n\n${renderedFocusTemplate}`;
+}

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

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logger } from '../../core/logging.js';
+import { buildTranslationReviewGuidance } from './translation-review-policy.js';
+const MAX_BODY_CHARS = 4000;
+let cachedStandardsSection = null;
+const REVIEW_TASK_DIR = path.dirname(fileURLToPath(import.meta.url));
+const STANDARDS_PROMPTS_DIR = path.resolve(REVIEW_TASK_DIR, '../../../src/review/prompts');
+function loadOutlineMap() {
+    try {
+        const mapPath = path.join(STANDARDS_PROMPTS_DIR, 'outline-map.json');
+        const raw = fs.readFileSync(mapPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        logger.warn('Failed to load outline map', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return {};
+    }
+}
+export function loadStandardsSection() {
+    if (cachedStandardsSection !== null) {
+        return cachedStandardsSection;
+    }
+    try {
+        const outlineMap = loadOutlineMap();
+        const files = fs
+            .readdirSync(STANDARDS_PROMPTS_DIR)
+            .filter((f) => f.endsWith('.md'))
+            .sort();
+        const sections = files.map((file) => {
+            const content = fs.readFileSync(path.join(STANDARDS_PROMPTS_DIR, file), 'utf8');
+            const title = file.replace('.md', '');
+            const entry = outlineMap[file];
+            const header = entry ? `### ${title}\n\nHandbook: ${entry.url}` : `### ${title}`;
+            return `${header}\n\n${content}`;
+        });
+        const result = sections.join('\n\n---\n\n');
+        cachedStandardsSection = result;
+        return result;
+    }
+    catch (error) {
+        logger.warn('Failed to load standards section', {
+            error: error instanceof Error ? error.message : String(error),
+            dir: STANDARDS_PROMPTS_DIR,
+        });
+        return '';
+    }
+}
+function formatPrConversation(prConversation) {
+    const promptText = prConversation?.promptText.trim();
+    if (promptText) {
+        return promptText;
+    }
+    if (prConversation?.stats?.summarizationFailed && prConversation.stats.rawChars > 0) {
+        return 'Prior PR conversation existed but could not be included.';
+    }
+    return 'No prior PR conversation was included.';
+}
+export function buildReviewPromptVariables({ repoOwner, repoName, prNumber, prTitle, prBody, prConversation, prAuthor, baseRef, headRef, diffSection, truncated, standardsSection, }) {
+    const safeBody = (prBody ?? '').trim();
+    const condensedBody = safeBody
+        ? safeBody.slice(0, MAX_BODY_CHARS)
+        : 'No PR description was provided.';
+    const fullDiffSection = diffSection + (truncated ? '\n[Diff was truncated to fit token limits]' : '');
+    return {
+        REPO_FULL: `${repoOwner}/${repoName}`,
+        PR_NUMBER: String(prNumber),
+        PR_TITLE: prTitle || 'Untitled',
+        PR_AUTHOR: prAuthor,
+        BASE_REF: baseRef,
+        HEAD_REF: headRef,
+        PR_BODY: condensedBody,
+        PR_CONVERSATION: formatPrConversation(prConversation),
+        DIFF_SECTION: fullDiffSection,
+        STANDARDS_SECTION: standardsSection,
+        TRANSLATION_REVIEW_GUIDANCE: buildTranslationReviewGuidance(repoOwner, repoName),
+    };
+}

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

@@ -0,0 +1,48 @@
+import { buildDatadogLink, deriveLangfuseTraceId } from 'doistbot-shared-contracts';
+const FEEDBACK_ISSUE_URL = 'https://github.com/todoist/doistbot-app/issues/new';
+const FEEDBACK_ISSUE_TEMPLATE = 'review-feedback.yml';
+const FEEDBACK_LINK_TEXT = 'Share Feedback';
+const DATADOG_LINK_TEXT = 'Review Logs';
+const LANGFUSE_LINK_TEXT = 'Trace';
+const REVIEW_FEEDBACK_FOOTER_REGEX = /\n*<sub>\[Share Feedback\][\s\S]*?<\/sub>\s*$/i;
+export function buildReviewFeedbackIssueUrl({ owner, repo, prNumber, deliveryId, }) {
+    const feedbackUrl = new URL(FEEDBACK_ISSUE_URL);
+    const prUrl = `https://github.com/${owner}/${repo}/pull/${prNumber}`;
+    const datadogLink = buildDatadogLink(deliveryId);
+    feedbackUrl.searchParams.set('template', FEEDBACK_ISSUE_TEMPLATE);
+    feedbackUrl.searchParams.set('title', `Review feedback for ${owner}/${repo}`);
+    feedbackUrl.searchParams.set('pr_url', prUrl);
+    if (datadogLink) {
+        feedbackUrl.searchParams.set('datadog_url', datadogLink);
+    }
+    if (deliveryId) {
+        feedbackUrl.searchParams.set('trace_id', deriveLangfuseTraceId(deliveryId));
+    }
+    return feedbackUrl.toString();
+}
+function buildLangfuseTraceLink(deliveryId) {
+    const prefix = process.env.LANGFUSE_TRACE_URL_PREFIX?.trim();
+    if (!prefix || !deliveryId)
+        return undefined;
+    return `${prefix}${deriveLangfuseTraceId(deliveryId)}`;
+}
+export function stripReviewFeedbackFooter(body) {
+    return body.replace(REVIEW_FEEDBACK_FOOTER_REGEX, '').trim();
+}
+export function appendReviewFeedbackLink(summary, params) {
+    const trimmedSummary = summary.trim();
+    if (!trimmedSummary) {
+        return '';
+    }
+    const feedbackUrl = buildReviewFeedbackIssueUrl(params);
+    const footerLinks = [`[${FEEDBACK_LINK_TEXT}](${feedbackUrl})`];
+    const datadogLink = buildDatadogLink(params.deliveryId);
+    if (datadogLink) {
+        footerLinks.push(`[${DATADOG_LINK_TEXT}](${datadogLink})`);
+    }
+    const langfuseLink = buildLangfuseTraceLink(params.deliveryId);
+    if (langfuseLink) {
+        footerLinks.push(`[${LANGFUSE_LINK_TEXT}](${langfuseLink})`);
+    }
+    return `${trimmedSummary}\n\n<sub>${footerLinks.join(' • ')}</sub>`;
+}