@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-triage/model.js

@@ -0,0 +1,124 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { DEFAULT_PI_MODELS, invokePiPrompt, } from '../../core/pi.js';
+import { recordEvent, startToolSpan, withPhase } from '../../core/tracing.js';
+const ISSUE_TRIAGE_TIMEOUT_MS = 90 * 60 * 1000;
+const TRIAGE_PROVIDER = 'openai';
+export async function invokeTriageModel({ prompt, apiKey, cwd, timeoutMs = ISSUE_TRIAGE_TIMEOUT_MS, extraEnv, thinkingLevel, modelName = DEFAULT_PI_MODELS[TRIAGE_PROVIDER], capabilityPreset = 'shell-focused', 
+// Callers on other paths (e.g. fix generation) pass their own phase name
+// so model telemetry stays separable per flow.
+phaseName = 'triage.model', }) {
+    return withPhase(phaseName, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': TRIAGE_PROVIDER,
+        'gen_ai.request.model': modelName,
+    }, async (span) => {
+        // pi emits tool start/end across separate onProgress callbacks, so
+        // tool spans are managed manually (the documented exception to
+        // "withPhase everywhere"). startToolSpan captures context.active()
+        // at call time, parenting each tool span under THIS model span.
+        const inFlightTools = new Map();
+        function toolKey(event) {
+            return event.toolCallId ?? event.toolName ?? '';
+        }
+        function onProgress(event) {
+            switch (event.type) {
+                case 'tool_start': {
+                    const toolCallId = event.toolCallId;
+                    const key = toolKey(event);
+                    // Overlapping same-name tools without a toolCallId
+                    // collide on the key; close the displaced span so it
+                    // is never leaked un-ended.
+                    const displaced = inFlightTools.get(key);
+                    if (displaced) {
+                        displaced.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: 'replaced by overlapping same-name tool without toolCallId',
+                        });
+                        displaced.end();
+                    }
+                    const toolSpan = startToolSpan(event.toolName, {
+                        'gen_ai.operation.name': 'execute_tool',
+                        'gen_ai.tool.name': event.toolName,
+                        ...(toolCallId ? { 'gen_ai.tool.call.id': toolCallId } : {}),
+                    });
+                    inFlightTools.set(key, toolSpan);
+                    return;
+                }
+                case 'tool_end': {
+                    const key = toolKey(event);
+                    const toolSpan = inFlightTools.get(key);
+                    if (toolSpan) {
+                        if (event.isError) {
+                            toolSpan.setStatus({
+                                code: SpanStatusCode.ERROR,
+                                message: 'tool reported error',
+                            });
+                        }
+                        toolSpan.end();
+                        inFlightTools.delete(key);
+                    }
+                    return;
+                }
+                case 'thinking':
+                case 'responding': {
+                    // Liveness signal for long model phases: pi already
+                    // throttles these to one per 30s. Emitted as point-in-time
+                    // events (correlated to this model span), NOT spans —
+                    // they are heartbeats, not boundaries.
+                    recordEvent('model.heartbeat', { state: event.type });
+                }
+                // agent_start/agent_end duplicate this phase span's own
+                // boundaries and tool_update is covered by the open tool
+                // span — intentionally no emission for those.
+            }
+        }
+        const startedAt = Date.now();
+        const result = await invokePiPrompt({
+            provider: TRIAGE_PROVIDER,
+            apiKey,
+            prompt,
+            cwd,
+            timeoutMs,
+            extraEnv,
+            capabilityPreset,
+            ...(thinkingLevel ? { thinkingLevel } : {}),
+            ...(modelName ? { modelName } : {}),
+            onProgress,
+        });
+        // Force-end any tool spans pi never closed (defensive — pi's stream
+        // is ordered, but if a tool_end was lost we don't want hanging spans).
+        for (const [, toolSpan] of inFlightTools) {
+            toolSpan.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: 'tool span did not receive matching end',
+            });
+            toolSpan.end();
+        }
+        inFlightTools.clear();
+        const durationMs = Date.now() - startedAt;
+        if (!result.ok) {
+            // Mark the model phase as failed. withPhase does NOT force OK on
+            // success, so this ERROR status survives to the phase.end line.
+            span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+            return {
+                ok: false,
+                error: result.error,
+                durationMs,
+                timedOut: result.timedOut,
+                telemetry: result.telemetry,
+            };
+        }
+        const output = result.output.trim();
+        if (!output) {
+            const message = 'Pi triage model did not produce an assistant response';
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            return {
+                ok: false,
+                error: message,
+                durationMs,
+                timedOut: false,
+            };
+        }
+        return { ok: true, output, durationMs, telemetry: result.telemetry };
+    });
+}

package/sandbox/dist/tasks/issue-triage/output.js

@@ -0,0 +1,164 @@
+import { isDeepStrictEqual } from 'node:util';
+import { SpanStatusCode } from '@opentelemetry/api';
+import { fillPromptTemplate } from '../../core/prompt-template.js';
+import { withPhase } from '../../core/tracing.js';
+import { MAX_TRIAGE_COMMENT_CHARS, TRIAGE_MARKER } from './markers.js';
+import { escapeReportText, parseTriageAnalysis, readTriageReport, renderTriageReport, reportAssessment, reportForFix, TRIAGE_METADATA_MARKER, TRIAGE_REJECTED_MARKER, TRIAGE_REPORT_MARKER, } from './report.js';
+import { createTriageReport } from './report-history.js';
+const UNRESOLVED_LABELS_TEMPLATE = `I couldn’t resolve triage repositories from the current issue labels.
+
+Reason: $REASON
+
+Detected labels: Product=[$PRODUCTS] App=[$APPS] Team=[$TEAMS]
+
+Please update labels and run \`@doistbot /triage\` again.
+Expected examples:
+- \`Product:Todoist\` + \`App:Android\`
+- \`Product:Comms\` + \`App:Android\`
+- \`Product:Todoist\` + \`App:All\``;
+export function buildTriageFailureMessage(reason) {
+    const normalizedReason = reason.trim().replace(/\s+/g, ' ');
+    return `Triage failed: ${normalizedReason || 'Unknown error'}`;
+}
+export function buildUnresolvedLabelsOutput({ reason, productLabels, appLabels, teamLabels, }) {
+    const products = productLabels.length > 0 ? productLabels.join(', ') : '(none)';
+    const apps = appLabels.length > 0 ? appLabels.join(', ') : '(none)';
+    const teams = teamLabels.length > 0 ? teamLabels.join(', ') : '(none)';
+    return fillPromptTemplate(UNRESOLVED_LABELS_TEMPLATE, {
+        REASON: reason,
+        PRODUCTS: products,
+        APPS: apps,
+        TEAMS: teams,
+    });
+}
+const VALID_CLASSIFICATIONS = [
+    'auto-fixable',
+    'speculative',
+    'logs-needed',
+    'needs-human',
+    'insufficient-context',
+];
+const VALID_CONFIDENCES = ['high', 'medium', 'low'];
+const FIX_ASSESSMENT_HEADING = '## Automated Fix Assessment';
+export function parseFixAssessment(triageOutput) {
+    if (triageOutput.includes(TRIAGE_REJECTED_MARKER))
+        return null;
+    if (triageOutput.includes(TRIAGE_REPORT_MARKER) ||
+        triageOutput.includes(TRIAGE_METADATA_MARKER)) {
+        try {
+            const report = readTriageReport(triageOutput);
+            return report ? reportAssessment(report) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    const headingPattern = new RegExp(`^${FIX_ASSESSMENT_HEADING}\\s*$`, 'm');
+    const headingMatch = triageOutput.match(headingPattern);
+    if (headingMatch?.index === undefined) {
+        return null;
+    }
+    const afterHeading = triageOutput.slice(headingMatch.index + headingMatch[0].length);
+    const nextHeadingIndex = afterHeading.search(/^##\s/m);
+    const sectionBody = nextHeadingIndex >= 0 ? afterHeading.slice(0, nextHeadingIndex) : afterHeading;
+    const jsonMatch = sectionBody.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+    if (!jsonMatch?.[1]) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonMatch[1]);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        return null;
+    }
+    const { classification, confidence, scope, targetRepo } = parsed;
+    if (typeof classification !== 'string' ||
+        typeof confidence !== 'string' ||
+        typeof scope !== 'string' ||
+        !VALID_CLASSIFICATIONS.includes(classification) ||
+        !VALID_CONFIDENCES.includes(confidence)) {
+        return null;
+    }
+    return {
+        classification: classification,
+        confidence: confidence,
+        scope,
+        ...(typeof targetRepo === 'string' && targetRepo ? { targetRepo } : {}),
+    };
+}
+function rejectedOutput(reason, rawOutput) {
+    const start = `${escapeReportText(buildTriageFailureMessage(reason).slice(0, 1000))}\n\n${TRIAGE_REJECTED_MARKER}\n`;
+    const end = '\n-->';
+    const budget = MAX_TRIAGE_COMMENT_CHARS - TRIAGE_MARKER.length - 2 - start.length - end.length;
+    const escaped = escapeReportText(rawOutput);
+    if (escaped.length <= budget)
+        return start + escaped + end;
+    const notice = '\n\n[Output shortened to fit the comment limit.]';
+    let excerpt = '';
+    for (const character of rawOutput) {
+        const escapedCharacter = escapeReportText(character);
+        if (excerpt.length + escapedCharacter.length > budget - notice.length)
+            break;
+        excerpt += escapedCharacter;
+    }
+    return start + excerpt + notice + end;
+}
+export function validateTriageOutput(params) {
+    return withPhase('triage.output', { 'output.length': params.rawOutput.length }, async (span) => {
+        function reject(error) {
+            span.setAttributes({ 'output.quality_check.passed': false });
+            span.setStatus({ code: SpanStatusCode.ERROR, message: error });
+            return {
+                ok: false,
+                error,
+                commentOutput: rejectedOutput(error, params.rawOutput),
+            };
+        }
+        try {
+            const analysis = parseTriageAnalysis(params.rawOutput);
+            const { decision, reinvestigation } = analysis;
+            if (params.expectedMetadata &&
+                !isDeepStrictEqual({ decision, reinvestigation }, params.expectedMetadata)) {
+                throw new Error('Shortening the report changed its workflow metadata.');
+            }
+            const report = createTriageReport({
+                analysis,
+                issueUrl: params.issueUrl,
+                repositories: params.repositories,
+                history: params.history,
+            });
+            const commentOutput = renderTriageReport(report);
+            if (params.enforceCommentLimit !== false &&
+                commentOutput.length + TRIAGE_MARKER.length + 2 > MAX_TRIAGE_COMMENT_CHARS) {
+                return {
+                    ...reject(`Triage report exceeds ${MAX_TRIAGE_COMMENT_CHARS} characters.`),
+                    reason: 'too-long',
+                    analysis,
+                };
+            }
+            span.setAttributes({
+                'output.quality_check.passed': true,
+                'output.classification': report.analysis.decision.classification,
+                'output.completed_logging_rounds': report.completedLoggingRounds,
+            });
+            return {
+                ok: true,
+                report,
+                commentOutput,
+                output: reportForFix(report),
+                assessment: reportAssessment(report),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ...reject(message),
+                reason: 'invalid',
+            };
+        }
+    });
+}