@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/main.js

@@ -0,0 +1,51 @@
+import { withLangfuseTaskContext } from './core/langfuse-session.js';
+import { setupTracing } from './core/tracing-setup.js';
+// Register the OTel SDK before any task module loads — withPhase/startToolSpan
+// are no-ops until a tracer provider is registered.
+setupTracing();
+const taskType = process.env.TASK_TYPE ?? 'review';
+// Tasks run (or kick off) on import, so the wrapper's async context flows into
+// every span the task creates.
+await withLangfuseTaskContext(async () => {
+    switch (taskType) {
+        case 'chat':
+            await import('./tasks/chat/chat.js');
+            break;
+        case 'issue-summarize':
+            await import('./tasks/issue-summarize/summarize.js');
+            break;
+        case 'sentry-triage': {
+            const { main } = await import('./tasks/sentry-triage/triage.js');
+            await main();
+            break;
+        }
+        case 'issue-triage':
+            await import('./tasks/issue-triage/triage.js');
+            break;
+        case 'issue-fix-retry':
+            await import('./tasks/issue-fix-retry/fix-retry.js');
+            break;
+        case 'fix-loop-promotion':
+            await import('./tasks/issue-triage/fix-loop/promotion-task.js');
+            break;
+        case 'persist-logs': {
+            const { main } = await import('./tasks/persist-logs/persist-logs.js');
+            await main();
+            break;
+        }
+        case 'refresh-s3-urls': {
+            const { main } = await import('./tasks/refresh-s3-urls/refresh-s3-urls.js');
+            await main();
+            break;
+        }
+        case 'review':
+            await import('./tasks/review/review.js');
+            break;
+        case 'review-slice-plan':
+            await import('./tasks/review-slice-plan/review-slice-plan.js');
+            break;
+        default:
+            process.stderr.write(`Unknown TASK_TYPE: ${taskType}\n`);
+            process.exit(1);
+    }
+});

package/sandbox/dist/providers/config.js

@@ -0,0 +1,23 @@
+export const DEFAULT_PROVIDER_TIMEOUT_MS = 10 * 60 * 1000;
+function parseTimeoutMs(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return null;
+    }
+    return parsed;
+}
+export function resolveProviderTimeoutMs(explicitTimeoutMs) {
+    if (typeof explicitTimeoutMs === 'number' &&
+        Number.isFinite(explicitTimeoutMs) &&
+        explicitTimeoutMs > 0) {
+        return explicitTimeoutMs;
+    }
+    const sharedTimeout = parseTimeoutMs(process.env.REVIEW_MODEL_TIMEOUT_MS);
+    if (sharedTimeout != null) {
+        return sharedTimeout;
+    }
+    return DEFAULT_PROVIDER_TIMEOUT_MS;
+}

package/sandbox/dist/providers/credentials.js

@@ -0,0 +1,40 @@
+import { parsePiAuthProviderId } from '../core/pi.js';
+export function resolveReviewProviderCredential(credential) {
+    if (typeof credential === 'string') {
+        const apiKey = credential.trim();
+        if (!apiKey) {
+            return undefined;
+        }
+        const piAuthProviderId = parsePiAuthProviderId(apiKey);
+        return {
+            apiKey,
+            ...(piAuthProviderId ? { piProviderId: piAuthProviderId } : {}),
+        };
+    }
+    if (!credential) {
+        return undefined;
+    }
+    const apiKey = credential.apiKey.trim();
+    if (!apiKey) {
+        return undefined;
+    }
+    const piAuthProviderId = parsePiAuthProviderId(apiKey);
+    const piProviderId = piAuthProviderId ?? credential.piProviderId;
+    return {
+        apiKey,
+        ...(piProviderId ? { piProviderId } : {}),
+        ...(credential.modelName ? { modelName: credential.modelName } : {}),
+    };
+}
+export function hasReviewProviderCredential(credential) {
+    return resolveReviewProviderCredential(credential) !== undefined;
+}
+export function getReviewProviderCredential(apiKeys, provider) {
+    return resolveReviewProviderCredential(apiKeys[provider]);
+}
+export function createOpenRouterCredential(apiKey) {
+    return {
+        apiKey,
+        piProviderId: 'openrouter',
+    };
+}

package/sandbox/dist/providers/gemini.js

@@ -0,0 +1,28 @@
+/**
+ * Gemini provider for the multi-model code review system.
+ * Uses the Pi harness instead of the Gemini CLI.
+ */
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS } from '../core/pi.js';
+import { resolveProviderTimeoutMs } from './config.js';
+import { extractJsonFromResponse } from './helpers.js';
+import { runPiReviewProvider } from './pi-review.js';
+export class GeminiProvider {
+    name = 'gemini';
+    async review(prompt, config) {
+        const modelName = config.modelName ??
+            (config.piProviderId === 'openrouter'
+                ? DEFAULT_OPENROUTER_MODELS.gemini
+                : DEFAULT_PI_MODELS.gemini) ??
+            DEFAULT_PI_MODELS.gemini;
+        return await runPiReviewProvider({
+            provider: this.name,
+            modelName,
+            prompt,
+            config: {
+                ...config,
+                timeout: resolveProviderTimeoutMs(config.timeout),
+            },
+            parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
+        });
+    }
+}

package/sandbox/dist/providers/helpers.js

@@ -0,0 +1,253 @@
+/**
+ * Shared helper functions for provider implementations.
+ */
+import { randomUUID } from 'crypto';
+import { logger } from '../core/logging.js';
+import { isRawReviewResult } from './schemas.js';
+const RAW_MODEL_LOG_CHUNK_CHARS = 8000;
+const REVIEW_LOG_ENGINE = 'multi_focus';
+const PROVIDER_ERROR_DETAILS_MAX_DEPTH = 8;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseJsonValue(value) {
+    try {
+        return JSON.parse(value.trim());
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readProviderErrorDetails(error) {
+    const rawError = error instanceof Error ? error.message : String(error);
+    const details = { rawError };
+    function visit(value, depth) {
+        if (depth > PROVIDER_ERROR_DETAILS_MAX_DEPTH) {
+            return;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            const parsed = parseJsonValue(trimmed);
+            if (isRecord(parsed)) {
+                visit(parsed, depth + 1);
+                return;
+            }
+            if (!details.reason && trimmed) {
+                details.reason = trimmed;
+            }
+            return;
+        }
+        if (!isRecord(value)) {
+            return;
+        }
+        if (value.error !== undefined) {
+            visit(value.error, depth + 1);
+        }
+        if (typeof value.message === 'string') {
+            visit(value.message, depth + 1);
+        }
+        if (details.errorCode === undefined &&
+            (typeof value.code === 'number' || typeof value.code === 'string')) {
+            details.errorCode = value.code;
+        }
+        if (details.status === undefined && typeof value.status === 'string') {
+            details.status = value.status;
+        }
+    }
+    visit(rawError, 0);
+    return details;
+}
+function redactSensitiveStrings(content) {
+    return content
+        .replace(/(sk-[A-Za-z0-9_-]{10,})/g, '[REDACTED_OPENAI_KEY]')
+        .replace(/(AIza[0-9A-Za-z_-]{20,})/g, '[REDACTED_GEMINI_KEY]')
+        .replace(/(anthropic_[A-Za-z0-9_-]{10,})/g, '[REDACTED_ANTHROPIC_KEY]')
+        .replace(/(Bearer\s+)[A-Za-z0-9._-]+/gi, '$1[REDACTED_TOKEN]');
+}
+function splitIntoChunks(content, chunkChars) {
+    if (!content) {
+        return [];
+    }
+    const chunks = [];
+    for (let index = 0; index < content.length; index += chunkChars) {
+        chunks.push(content.slice(index, index + chunkChars));
+    }
+    return chunks;
+}
+export function buildRawModelOutputEntries(content) {
+    const text = redactSensitiveStrings(content);
+    const chunks = splitIntoChunks(text, RAW_MODEL_LOG_CHUNK_CHARS);
+    const chunkCount = chunks.length;
+    return chunks.map((chunk, index) => ({
+        chunk,
+        chunkCount,
+        chunkIndex: index + 1,
+        loggedLength: text.length,
+        originalLength: content.length,
+    }));
+}
+export function logRawModelOutput({ model, stage, success, status, durationMs, stdout, stderr, }) {
+    const streams = [
+        { name: 'stdout', value: stdout },
+        { name: 'stderr', value: stderr },
+    ];
+    for (const stream of streams) {
+        const output = stream.value ?? '';
+        if (!output) {
+            continue;
+        }
+        const entries = buildRawModelOutputEntries(output);
+        for (const entry of entries) {
+            logger.info('Review model raw output', {
+                model,
+                engine: REVIEW_LOG_ENGINE,
+                stage,
+                success,
+                status: status ?? null,
+                durationMs,
+                stream: stream.name,
+                chunkIndex: entry.chunkIndex,
+                chunkCount: entry.chunkCount,
+                originalLength: entry.originalLength,
+                loggedLength: entry.loggedLength,
+                output: entry.chunk,
+            });
+        }
+    }
+}
+/**
+ * Parses raw findings from a model response into normalized ReviewFinding objects.
+ */
+export function parseRawFindings(comments, modelName) {
+    return comments
+        .filter((comment) => {
+        const path = typeof comment.path === 'string' ? comment.path.trim() : '';
+        const line = Number(comment.line);
+        const body = typeof comment.body === 'string' ? comment.body.trim() : '';
+        return path !== '' && Number.isInteger(line) && body !== '';
+    })
+        .map((comment) => {
+        let side = 'RIGHT';
+        if (typeof comment.side === 'string') {
+            const upperSide = comment.side.toUpperCase();
+            if (upperSide === 'LEFT' || upperSide === 'RIGHT') {
+                side = upperSide;
+            }
+        }
+        return {
+            id: randomUUID(),
+            path: comment.path.trim(),
+            line: Number(comment.line),
+            side,
+            body: comment.body.trim(),
+            sourceModel: modelName,
+            ...(comment.translationResolution
+                ? { translationResolution: comment.translationResolution }
+                : {}),
+        };
+    });
+}
+/**
+ * Normalizes structured model output into a single provider response shape.
+ */
+export function normalizeParsedModelOutput(parsed, modelName) {
+    if (isRawReviewResult(parsed)) {
+        return {
+            summary: parsed.summary,
+            findings: parseRawFindings(parsed.comments, modelName),
+        };
+    }
+    throw new Error('Model output did not match review schema');
+}
+function extractFencedJsonCandidates(content) {
+    const matches = content.match(/```json\s*([\s\S]*?)\s*```/gi);
+    if (!matches) {
+        return [];
+    }
+    return matches
+        .map((block) => block
+        .replace(/^```json\s*/i, '')
+        .replace(/\s*```$/, '')
+        .trim())
+        .filter(Boolean);
+}
+function extractBalancedJsonCandidates(content) {
+    const candidates = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaping = false;
+    for (let index = 0; index < content.length; index++) {
+        const char = content[index];
+        if (char === undefined) {
+            continue;
+        }
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaping = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === '{') {
+            if (depth === 0) {
+                start = index;
+            }
+            depth += 1;
+            continue;
+        }
+        if (char === '}') {
+            if (depth === 0) {
+                continue;
+            }
+            depth -= 1;
+            if (depth === 0 && start !== -1) {
+                candidates.push(content.slice(start, index + 1));
+                start = -1;
+            }
+        }
+    }
+    return candidates;
+}
+/**
+ * Returns JSON-looking candidates from a response string in parser preference order.
+ * Fenced JSON blocks are preferred over balanced objects because models often include
+ * code snippets or object-shaped prose before the final fenced response.
+ */
+export function extractJsonCandidatesFromResponse(content) {
+    return [
+        ...extractFencedJsonCandidates(content).reverse(),
+        ...extractBalancedJsonCandidates(content).reverse(),
+    ];
+}
+/**
+ * Extracts JSON from a response string that may contain additional text.
+ * Prefers valid fenced JSON blocks, then valid balanced JSON objects.
+ * Throws when no valid JSON candidate can be parsed.
+ */
+export function extractJsonFromResponse(content) {
+    for (const candidate of extractJsonCandidatesFromResponse(content)) {
+        if (!candidate) {
+            continue;
+        }
+        try {
+            JSON.parse(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error('No valid JSON object found in model response');
+}

package/sandbox/dist/providers/index.js

@@ -0,0 +1,27 @@
+/**
+ * Provider factory and exports for the multi-model code review system.
+ */
+import { GeminiProvider } from './gemini.js';
+import { OpenAIProvider } from './openai.js';
+import { OpenRouterPiProvider } from './openrouter-pi.js';
+export { GeminiProvider } from './gemini.js';
+export { OpenAIProvider } from './openai.js';
+export { OpenRouterPiProvider } from './openrouter-pi.js';
+export * from './types.js';
+const providers = {
+    deepseek: new OpenRouterPiProvider('deepseek'),
+    gemini: new GeminiProvider(),
+    grok: new OpenRouterPiProvider('grok'),
+    zai: new OpenRouterPiProvider('zai'),
+    openai: new OpenAIProvider(),
+};
+/**
+ * Gets a provider instance by name.
+ */
+export function getProvider(name) {
+    const provider = providers[name];
+    if (!provider) {
+        throw new Error(`Unknown provider: ${name}`);
+    }
+    return provider;
+}

package/sandbox/dist/providers/openai.js

@@ -0,0 +1,23 @@
+/**
+ * OpenAI provider for the multi-model code review system.
+ * Uses the Pi harness instead of the Codex CLI.
+ */
+import { DEFAULT_PI_MODELS } from '../core/pi.js';
+import { resolveProviderTimeoutMs } from './config.js';
+import { extractJsonFromResponse } from './helpers.js';
+import { runPiReviewProvider } from './pi-review.js';
+export class OpenAIProvider {
+    name = 'openai';
+    async review(prompt, config) {
+        return await runPiReviewProvider({
+            provider: this.name,
+            modelName: config.modelName ?? DEFAULT_PI_MODELS.openai,
+            prompt,
+            config: {
+                ...config,
+                timeout: resolveProviderTimeoutMs(config.timeout),
+            },
+            parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
+        });
+    }
+}

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

@@ -0,0 +1,25 @@
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS } from '../core/pi.js';
+import { resolveProviderTimeoutMs } from './config.js';
+import { extractJsonFromResponse } from './helpers.js';
+import { runPiReviewProvider } from './pi-review.js';
+export class OpenRouterPiProvider {
+    name;
+    fallbackModelName;
+    constructor(name, fallbackModelName = DEFAULT_OPENROUTER_MODELS[name] ??
+        DEFAULT_PI_MODELS[name]) {
+        this.name = name;
+        this.fallbackModelName = fallbackModelName;
+    }
+    async review(prompt, config) {
+        return await runPiReviewProvider({
+            provider: this.name,
+            modelName: config.modelName ?? this.fallbackModelName,
+            prompt,
+            config: {
+                ...config,
+                timeout: resolveProviderTimeoutMs(config.timeout),
+            },
+            parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
+        });
+    }
+}