@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/providers/pi-review.js

@@ -0,0 +1,301 @@
+import { WORKSPACE_DIR } from '../core/environment.js';
+import { logger } from '../core/logging.js';
+import { createPiInvoker, parsePiAuthProviderId, PI_PROVIDER_BY_DOISTBOT_PROVIDER, toPiInvocationTelemetryFields, } from '../core/pi.js';
+import { logPiProgressEvent } from '../core/pi-progress-logging.js';
+import { DEFAULT_PROVIDER_TIMEOUT_MS } from './config.js';
+import { logRawModelOutput, normalizeParsedModelOutput } from './helpers.js';
+const VERBOSE_PI_PROGRESS_LOGS = process.env.DOISTBOT_VERBOSE_PI_PROGRESS === 'true';
+const VERBOSE_PI_RAW_OUTPUT_LOGS = process.env.DOISTBOT_VERBOSE_PI_RAW_OUTPUT === 'true';
+const REVIEW_LOG_ENGINE = 'multi_focus';
+export const REVIEW_PI_EXECUTION_LIMITS = {
+    softTimeMs: 5 * 60 * 1000,
+    softToolCalls: 40,
+    hardTimeMs: 8 * 60 * 1000,
+    hardToolCalls: 65,
+};
+export const REVIEW_PI_PROCESS_KILL_MS = DEFAULT_PROVIDER_TIMEOUT_MS;
+const REVIEW_PI_SYSTEM_PROMPT = 'You are running inside doistbot in a non-interactive environment. Stay tightly focused on the review task in the user prompt. Read only the files that are directly relevant to the changed code, the explicitly named guidance files, and any immediately connected definitions needed to verify a concrete finding. Do not broadly explore the repository, inspect unrelated modules, or search history unless it is necessary to validate a specific review concern. Stop gathering context once you have enough evidence to answer the review task accurately.';
+function buildModelFailureResult({ model, error, durationMs, timedOut = false, telemetry, }) {
+    return {
+        model,
+        summary: '',
+        findings: [],
+        error,
+        timedOut,
+        durationMs,
+        ...(telemetry ? { telemetry } : {}),
+    };
+}
+function logReviewLatency({ provider, modelName, attempt, attemptsTotal, result, }) {
+    const telemetry = result.telemetry;
+    logger.info('Review model latency', {
+        model: provider,
+        engine: REVIEW_LOG_ENGINE,
+        model_name: modelName,
+        attempt,
+        attempts_total: attemptsTotal,
+        success: result.ok,
+        timed_out: !result.ok && result.timedOut,
+        stop_reason: result.stopReason,
+        duration_ms: result.durationMs,
+        ...(telemetry ? toPiInvocationTelemetryFields(telemetry) : {}),
+    });
+}
+function logReviewModelProgress(model, event) {
+    if (event.type === 'limit_reached') {
+        logger.warn('Review model execution limit reached', {
+            model,
+            engine: REVIEW_LOG_ENGINE,
+            level: event.level,
+            trigger: event.trigger,
+            elapsed_ms: event.elapsedMs,
+            tool_call_count: event.toolCallCount,
+        });
+        return;
+    }
+    logPiProgressEvent({
+        event,
+        messages: {
+            agentStart: 'Review model agent started',
+            agentEnd: 'Review model agent finished',
+            thinking: 'Review model still thinking',
+            responding: 'Review model streaming response',
+            toolStart: 'Review model tool started',
+            toolUpdate: 'Review model tool still running',
+            toolEnd: 'Review model tool finished',
+        },
+        meta: { model, engine: REVIEW_LOG_ENGINE },
+        logResponding: VERBOSE_PI_PROGRESS_LOGS,
+        logTools: VERBOSE_PI_PROGRESS_LOGS,
+    });
+}
+function emitReviewModelProgress(provider, event, config) {
+    config.onProgress?.({
+        ...event,
+        provider,
+    });
+    logReviewModelProgress(provider, event);
+}
+function logReviewRawModelOutput(args) {
+    if (!VERBOSE_PI_RAW_OUTPUT_LOGS) {
+        return;
+    }
+    logRawModelOutput(args);
+}
+function isOpenRouterBackedReviewRequest(provider, config) {
+    const resolvedPiProviderId = parsePiAuthProviderId(config.apiKey) ??
+        config.piProviderId ??
+        PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    return resolvedPiProviderId === 'openrouter';
+}
+export async function runPiReviewProvider(params) {
+    // Stamp the resolved model spec on every result (success or failure) so
+    // telemetry has the real model without re-deriving each provider's default.
+    const result = await runPiReviewProviderCore(params);
+    return { ...result, requestModel: params.modelName };
+}
+async function runPiReviewProviderCore({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, }) {
+    const startTime = Date.now();
+    const timeoutMs = Math.min(config.timeout ?? REVIEW_PI_PROCESS_KILL_MS, REVIEW_PI_PROCESS_KILL_MS);
+    let stdout = '';
+    let stderr = '';
+    let status = null;
+    let latestTelemetry;
+    logger.info('Review model request', {
+        model: provider,
+        engine: REVIEW_LOG_ENGINE,
+        promptLength: prompt.length,
+        modelName,
+        timeoutMs,
+        ...(isOpenRouterBackedReviewRequest(provider, config) && config.openRouterSessionId
+            ? { openRouterSessionId: config.openRouterSessionId }
+            : {}),
+    });
+    try {
+        const invoker = createPiInvoker({
+            provider,
+            apiKey: config.apiKey,
+            piProviderId: config.piProviderId,
+            cwd: config.workspaceDir ?? WORKSPACE_DIR,
+            onProgress: (event) => {
+                emitReviewModelProgress(provider, event, config);
+            },
+            capabilityPreset: 'read-only',
+            thinkingLevel: config.thinkingLevel,
+            systemPrompt: REVIEW_PI_SYSTEM_PROMPT,
+            noContextFiles: true,
+            openRouterSessionId: config.openRouterSessionId,
+            executionLimits: REVIEW_PI_EXECUTION_LIMITS,
+        });
+        for (let attempt = 0; attempt < prompts.length; attempt += 1) {
+            const result = await invoker.invoke({
+                prompt: prompts[attempt] ?? prompt,
+                modelName,
+                timeoutMs,
+            });
+            const durationMs = Date.now() - startTime;
+            latestTelemetry = result.telemetry;
+            stdout = result.ok ? result.output : '';
+            stderr = result.ok ? '' : result.error;
+            status = result.ok ? 0 : null;
+            logger.info('Review model tool usage', {
+                model: provider,
+                engine: REVIEW_LOG_ENGINE,
+                attempt: attempt + 1,
+                attemptsTotal: prompts.length,
+                attemptDurationMs: result.durationMs,
+                toolUsage: result.toolUsage,
+            });
+            logReviewLatency({
+                provider,
+                modelName,
+                attempt: attempt + 1,
+                attemptsTotal: prompts.length,
+                result,
+            });
+            if (!result.ok && result.timedOut) {
+                logReviewRawModelOutput({
+                    model: provider,
+                    stage: 'timeout',
+                    success: false,
+                    status,
+                    durationMs,
+                    stdout,
+                    stderr,
+                });
+                const error = result.error || `Pi ${provider} request timed out after ${timeoutMs}ms`;
+                logger.error('Review model failed', {
+                    model: provider,
+                    engine: REVIEW_LOG_ENGINE,
+                    error,
+                    durationMs,
+                });
+                return buildModelFailureResult({
+                    model: provider,
+                    error,
+                    durationMs,
+                    timedOut: true,
+                    telemetry: result.telemetry,
+                });
+            }
+            if (!result.ok) {
+                logReviewRawModelOutput({
+                    model: provider,
+                    stage: 'non-zero-exit',
+                    success: false,
+                    status,
+                    durationMs,
+                    stdout,
+                    stderr,
+                });
+                const error = `Pi ${provider} request failed: ${result.error.slice(0, 500)}`;
+                logger.error('Review model failed', {
+                    model: provider,
+                    engine: REVIEW_LOG_ENGINE,
+                    error,
+                    durationMs,
+                });
+                return buildModelFailureResult({
+                    model: provider,
+                    error,
+                    durationMs,
+                    telemetry: result.telemetry,
+                });
+            }
+            const output = result.output;
+            if (!output.trim()) {
+                logReviewRawModelOutput({
+                    model: provider,
+                    stage: 'empty-output',
+                    success: false,
+                    status,
+                    durationMs,
+                    stdout,
+                    stderr,
+                });
+                return buildModelFailureResult({
+                    model: provider,
+                    error: `Empty response from Pi ${provider} request`,
+                    durationMs,
+                    telemetry: result.telemetry,
+                });
+            }
+            try {
+                const normalized = normalizeParsedModelOutput(parseOutput(output), provider);
+                logger.info('Review model response', {
+                    model: provider,
+                    engine: REVIEW_LOG_ENGINE,
+                    findingsCount: normalized.findings.length,
+                    durationMs,
+                    parseMethod: 'extract_json',
+                });
+                if (VERBOSE_PI_RAW_OUTPUT_LOGS) {
+                    logger.info('Review model findings', {
+                        model: provider,
+                        engine: REVIEW_LOG_ENGINE,
+                        findings: normalized.findings,
+                    });
+                }
+                logReviewRawModelOutput({
+                    model: provider,
+                    stage: 'success',
+                    success: true,
+                    status,
+                    durationMs,
+                    stdout,
+                    stderr,
+                });
+                return {
+                    model: provider,
+                    summary: normalized.summary,
+                    findings: normalized.findings,
+                    durationMs,
+                    telemetry: result.telemetry,
+                };
+            }
+            catch (error) {
+                logReviewRawModelOutput({
+                    model: provider,
+                    stage: 'parse-error',
+                    success: false,
+                    status,
+                    durationMs,
+                    stdout,
+                    stderr,
+                });
+                throw error;
+            }
+        }
+        return buildModelFailureResult({
+            model: provider,
+            error: `Pi ${provider} request returned no usable output`,
+            durationMs: Date.now() - startTime,
+        });
+    }
+    catch (error) {
+        const durationMs = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logReviewRawModelOutput({
+            model: provider,
+            stage: 'exception',
+            success: false,
+            status,
+            durationMs,
+            stdout,
+            stderr,
+        });
+        logger.error('Review model failed', {
+            model: provider,
+            engine: REVIEW_LOG_ENGINE,
+            error: errorMessage,
+            durationMs,
+        });
+        return buildModelFailureResult({
+            model: provider,
+            error: errorMessage,
+            durationMs,
+            timedOut: errorMessage.toLowerCase().includes('timed out'),
+            telemetry: latestTelemetry,
+        });
+    }
+}

package/sandbox/dist/providers/process.js

@@ -0,0 +1,34 @@
+import { execFile } from 'child_process';
+const DEFAULT_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+function isTimeoutError(error) {
+    if (!error) {
+        return false;
+    }
+    return (error.code === 'ETIMEDOUT' ||
+        error.code === 143 ||
+        error.killed === true ||
+        error.signal === 'SIGTERM' ||
+        error.message.toLowerCase().includes('timed out') ||
+        error.message.toLowerCase().includes('etimedout'));
+}
+export function runProcess({ command, args, cwd, env, timeoutMs, maxBufferBytes = DEFAULT_MAX_BUFFER_BYTES, }) {
+    return new Promise((resolve) => {
+        execFile(command, args, {
+            cwd,
+            env,
+            encoding: 'utf8',
+            maxBuffer: maxBufferBytes,
+            timeout: timeoutMs,
+        }, (error, stdout, stderr) => {
+            const timedOut = isTimeoutError(error);
+            const status = typeof error?.code === 'number' ? error.code : error == null ? 0 : null;
+            resolve({
+                stdout: stdout ?? '',
+                stderr: stderr ?? '',
+                status,
+                timedOut,
+                errorMessage: error?.message,
+            });
+        });
+    });
+}

package/sandbox/dist/providers/schemas.js

@@ -0,0 +1,61 @@
+import { Ajv } from 'ajv';
+import { TRANSLATION_RESOLUTIONS } from './types.js';
+export const REVIEW_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        summary: { type: 'string' },
+        comments: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    path: { type: 'string', minLength: 1 },
+                    line: { type: 'integer', minimum: 1 },
+                    side: { type: 'string', enum: ['LEFT', 'RIGHT'] },
+                    body: { type: 'string', minLength: 1 },
+                    translationResolution: {
+                        type: 'string',
+                        enum: TRANSLATION_RESOLUTIONS,
+                    },
+                },
+                // Classification stays optional so omission keeps the finding instead of failing
+                // the entire review pass.
+                required: ['path', 'line', 'side', 'body'],
+            },
+        },
+    },
+    required: ['summary', 'comments'],
+};
+export const DEDUPE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        groups: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ids: {
+                        type: 'array',
+                        items: { type: 'string', minLength: 1 },
+                    },
+                    reason: { type: 'string' },
+                },
+                required: ['ids'],
+            },
+        },
+    },
+    required: ['groups'],
+};
+const ajv = new Ajv();
+const validateRawReviewResult = ajv.compile(REVIEW_SCHEMA);
+const validateDedupeResponse = ajv.compile(DEDUPE_SCHEMA);
+export function isRawReviewResult(value) {
+    return validateRawReviewResult(value);
+}
+export function isDedupeResponse(value) {
+    return validateDedupeResponse(value);
+}

package/sandbox/dist/providers/types.js

@@ -0,0 +1,4 @@
+export const TRANSLATION_RESOLUTIONS = [
+    'automated_sync_resolves',
+    'code_change_required_or_uncertain',
+];