@doist/doistbot-cli 1.0.10 → 1.0.12

package/sandbox/dist/core/repository-map.js

@@ -1,220 +1 @@
-const DEFAULT_REPOSITORY_OWNER = 'Doist';
-function createRepositoryTarget({ owner = DEFAULT_REPOSITORY_OWNER, repo, product, surfaces, }) {
-    return {
-        owner,
-        repo,
-        fullName: `${owner}/${repo}`,
-        product,
-        surfaces,
-    };
-}
-const TODOIST_REPOSITORIES = [
-    createRepositoryTarget({
-        repo: 'Todoist',
-        product: 'Todoist',
-        surfaces: ['backend'],
-    }),
-    createRepositoryTarget({
-        repo: 'todoist-web',
-        product: 'Todoist',
-        surfaces: ['web'],
-    }),
-    createRepositoryTarget({
-        repo: 'reactist',
-        product: 'Todoist',
-        surfaces: ['web'],
-    }),
-    createRepositoryTarget({
-        repo: 'todoist-ios',
-        product: 'Todoist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'dateist-ios',
-        product: 'Todoist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'textist-swift',
-        product: 'Todoist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'Todoist-Android',
-        product: 'Todoist',
-        surfaces: ['android'],
-    }),
-    createRepositoryTarget({
-        repo: 'Androist',
-        product: 'Todoist',
-        surfaces: ['android'],
-    }),
-    createRepositoryTarget({
-        repo: 'todoist-electron',
-        product: 'Todoist',
-        surfaces: ['desktop'],
-    }),
-    createRepositoryTarget({
-        repo: 'todoist-macos',
-        product: 'Todoist',
-        surfaces: ['desktop'],
-    }),
-    createRepositoryTarget({
-        repo: 'FilteristKt',
-        product: 'Todoist',
-        surfaces: ['android', 'ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'todoist-mcp',
-        product: 'Todoist',
-        surfaces: ['mcp'],
-    }),
-    createRepositoryTarget({
-        repo: 'todoist-cli',
-        product: 'Todoist',
-        surfaces: ['cli'],
-    }),
-];
-const TWIST_REPOSITORIES = [
-    createRepositoryTarget({
-        repo: 'Twist',
-        product: 'Twist',
-        surfaces: ['backend'],
-    }),
-    createRepositoryTarget({
-        repo: 'twist-web',
-        product: 'Twist',
-        surfaces: ['web'],
-    }),
-    createRepositoryTarget({
-        repo: 'reactist',
-        product: 'Twist',
-        surfaces: ['web'],
-    }),
-    createRepositoryTarget({
-        repo: 'twist-ios',
-        product: 'Twist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'doistui-swift',
-        product: 'Twist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'emojist-swift',
-        product: 'Twist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'keyboardist-swift',
-        product: 'Twist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'participantist-swift',
-        product: 'Twist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'reactionist-swift',
-        product: 'Twist',
-        surfaces: ['ios'],
-    }),
-    createRepositoryTarget({
-        repo: 'Twist-Android',
-        product: 'Twist',
-        surfaces: ['android'],
-    }),
-    createRepositoryTarget({
-        repo: 'Androist',
-        product: 'Twist',
-        surfaces: ['android'],
-    }),
-    createRepositoryTarget({
-        repo: 'twist-electron',
-        product: 'Twist',
-        surfaces: ['desktop'],
-    }),
-    createRepositoryTarget({
-        repo: 'twist-ai',
-        product: 'Twist',
-        surfaces: ['mcp'],
-    }),
-    createRepositoryTarget({
-        repo: 'twist-cli',
-        product: 'Twist',
-        surfaces: ['cli'],
-    }),
-];
-function dedupeRepositories(repositories) {
-    const unique = new Map();
-    for (const repository of repositories) {
-        unique.set(repository.fullName, repository);
-    }
-    return [...unique.values()];
-}
-function selectBySurface(repositories, surfaces) {
-    return dedupeRepositories(repositories.filter((repository) => repository.surfaces.some((surface) => surfaces.includes(surface))));
-}
-export const PRODUCT_REPOSITORIES = {
-    Todoist: TODOIST_REPOSITORIES,
-    Twist: TWIST_REPOSITORIES,
-};
-export const APP_TO_REPO_SELECTORS = {
-    all: (repositories) => dedupeRepositories(repositories),
-    android: (repositories) => selectBySurface(repositories, ['android']),
-    backend: (repositories) => selectBySurface(repositories, ['backend']),
-    cli: (repositories) => selectBySurface(repositories, ['cli']),
-    desktop: (repositories) => selectBySurface(repositories, ['desktop']),
-    ios: (repositories) => selectBySurface(repositories, ['ios']),
-    mcp: (repositories) => selectBySurface(repositories, ['mcp']),
-    web: (repositories) => selectBySurface(repositories, ['web']),
-};
-export const TEAM_TO_REPO_SELECTORS = {
-    all: (repositories) => dedupeRepositories(repositories),
-    android: (repositories) => selectBySurface(repositories, ['android']),
-    apple: (repositories) => selectBySurface(repositories, ['ios']),
-    backend: (repositories) => selectBySurface(repositories, ['backend']),
-    desktop: (repositories) => selectBySurface(repositories, ['desktop']),
-    frontend: (repositories) => selectBySurface(repositories, ['web']),
-    ios: (repositories) => selectBySurface(repositories, ['ios']),
-    mobile: (repositories) => dedupeRepositories([
-        ...selectBySurface(repositories, ['ios']),
-        ...selectBySurface(repositories, ['android']),
-    ]),
-    web: (repositories) => selectBySurface(repositories, ['web']),
-};
-export const RESOLUTION_PRECEDENCE = [
-    'Product label is required to resolve product-specific repositories.',
-    'App selectors take precedence over team selectors when App:* labels are present.',
-    'App:All expands to every repository in the selected product inventory.',
-    'Specific app labels remain authoritative even when team labels are broad.',
-    'Team selectors expand scope only when App:* labels are absent.',
-    'Missing, contradictory, or unsupported label sets return an unresolved result.',
-];
-export const PRODUCT_LABEL_ALIASES = {
-    todoist: 'Todoist',
-    twist: 'Twist',
-};
-export const APP_LABEL_ALIASES = {
-    all: 'all',
-    android: 'android',
-    backend: 'backend',
-    cli: 'cli',
-    desktop: 'desktop',
-    ios: 'ios',
-    mcp: 'mcp',
-    web: 'web',
-};
-export const TEAM_LABEL_ALIASES = {
-    all: 'all',
-    android: 'android',
-    apple: 'apple',
-    backend: 'backend',
-    desktop: 'desktop',
-    frontend: 'frontend',
-    ios: 'ios',
-    mobile: 'mobile',
-    web: 'web',
-};
+export { APP_LABEL_ALIASES, APP_TO_ROUTE_SELECTORS, findIssueRoute, findRepositoryRoutes, findRepositoryTarget, PRODUCT_LABEL_ALIASES, PRODUCT_ROUTES, RESOLUTION_PRECEDENCE, TEAM_LABEL_ALIASES, TEAM_TO_ROUTE_SELECTORS, } from 'doistbot-issue-routing';

package/sandbox/dist/core/repository-resolver.js

@@ -1,166 +1 @@
-import { extractScopedLabelValues, normalizeScopedLabelValue } from './label-parsing.js';
-import { APP_LABEL_ALIASES, APP_TO_REPO_SELECTORS, PRODUCT_LABEL_ALIASES, PRODUCT_REPOSITORIES, RESOLUTION_PRECEDENCE, TEAM_LABEL_ALIASES, TEAM_TO_REPO_SELECTORS, } from './repository-map.js';
-function uniqueValues(values) {
-    return [...new Set(values)];
-}
-function resolveProductLabels(productLabels) {
-    const products = [];
-    const unknown = [];
-    for (const rawLabel of productLabels) {
-        const canonical = PRODUCT_LABEL_ALIASES[normalizeScopedLabelValue(rawLabel)];
-        if (canonical) {
-            products.push(canonical);
-        }
-        else {
-            unknown.push(rawLabel);
-        }
-    }
-    return {
-        products: uniqueValues(products),
-        unknown: uniqueValues(unknown),
-    };
-}
-function resolveScopedLabels(labels, aliases) {
-    const resolved = [];
-    const unknown = [];
-    for (const rawLabel of labels) {
-        const canonical = aliases[normalizeScopedLabelValue(rawLabel)];
-        if (canonical) {
-            resolved.push(canonical);
-        }
-        else {
-            unknown.push(rawLabel);
-        }
-    }
-    return {
-        resolved: uniqueValues(resolved),
-        unknown: uniqueValues(unknown),
-    };
-}
-function dedupeRepositories(repositories) {
-    const unique = new Map();
-    for (const repository of repositories) {
-        unique.set(repository.fullName, repository);
-    }
-    return [...unique.values()];
-}
-function parseLabelScopes(labels) {
-    return {
-        productLabels: extractScopedLabelValues(labels, 'Product'),
-        appLabels: extractScopedLabelValues(labels, 'App'),
-        teamLabels: extractScopedLabelValues(labels, 'Team'),
-    };
-}
-export function resolveIssueRepositories(labels) {
-    const decisionPath = [...RESOLUTION_PRECEDENCE];
-    const { productLabels, appLabels, teamLabels } = parseLabelScopes(labels);
-    const productResolution = resolveProductLabels(productLabels);
-    const appResolution = resolveScopedLabels(appLabels, APP_LABEL_ALIASES);
-    const teamResolution = resolveScopedLabels(teamLabels, TEAM_LABEL_ALIASES);
-    const parsedLabels = {
-        allLabels: labels,
-        productLabels: productResolution.products,
-        appLabels: appResolution.resolved,
-        teamLabels: teamResolution.resolved,
-        unknownProductLabels: productResolution.unknown,
-        unknownAppLabels: appResolution.unknown,
-        unknownTeamLabels: teamResolution.unknown,
-    };
-    if (productResolution.products.length === 0) {
-        return {
-            status: 'unresolved',
-            reason: 'Missing Product:* label. Please add Product:Todoist or Product:Twist.',
-            confidence: 'low',
-            decisionPath,
-            repositories: [],
-            parsedLabels,
-        };
-    }
-    if (productResolution.products.length > 1) {
-        return {
-            status: 'unresolved',
-            reason: `Contradictory product labels: ${productResolution.products.join(', ')}`,
-            confidence: 'low',
-            decisionPath,
-            repositories: [],
-            parsedLabels,
-        };
-    }
-    const product = productResolution.products[0];
-    if (!product) {
-        return {
-            status: 'unresolved',
-            reason: 'Unable to resolve product labels.',
-            confidence: 'low',
-            decisionPath,
-            repositories: [],
-            parsedLabels,
-        };
-    }
-    const repositoriesForProduct = PRODUCT_REPOSITORIES[product];
-    if (appResolution.resolved.length > 0) {
-        decisionPath.push('Applied app selectors and skipped team selectors due App:* precedence.');
-        const selectedRepositories = dedupeRepositories(appResolution.resolved.flatMap((appLabel) => {
-            const selector = APP_TO_REPO_SELECTORS[appLabel];
-            return selector ? selector(repositoriesForProduct) : [];
-        }));
-        if (selectedRepositories.length === 0) {
-            return {
-                status: 'unresolved',
-                reason: `App labels did not map to repositories for product ${product}.`,
-                confidence: 'low',
-                decisionPath,
-                product,
-                repositories: [],
-                parsedLabels,
-            };
-        }
-        return {
-            status: 'resolved',
-            reason: appResolution.resolved.includes('all')
-                ? `Resolved using Product:${product} + App:All.`
-                : `Resolved using Product:${product} + App selectors (${appResolution.resolved.join(', ')}).`,
-            confidence: 'high',
-            decisionPath,
-            product,
-            repositories: selectedRepositories,
-            parsedLabels,
-        };
-    }
-    if (teamResolution.resolved.length > 0) {
-        decisionPath.push('No App:* labels found; applied team selectors.');
-        const selectedRepositories = dedupeRepositories(teamResolution.resolved.flatMap((teamLabel) => {
-            const selector = TEAM_TO_REPO_SELECTORS[teamLabel];
-            return selector ? selector(repositoriesForProduct) : [];
-        }));
-        if (selectedRepositories.length === 0) {
-            return {
-                status: 'unresolved',
-                reason: `Team labels did not map to repositories for product ${product}.`,
-                confidence: 'low',
-                decisionPath,
-                product,
-                repositories: [],
-                parsedLabels,
-            };
-        }
-        return {
-            status: 'resolved',
-            reason: `Resolved using Product:${product} + Team selectors (${teamResolution.resolved.join(', ')}).`,
-            confidence: 'medium',
-            decisionPath,
-            product,
-            repositories: selectedRepositories,
-            parsedLabels,
-        };
-    }
-    return {
-        status: 'unresolved',
-        reason: 'Missing App:* and Team:* labels. Add scope labels to continue triage.',
-        confidence: 'low',
-        decisionPath,
-        product,
-        repositories: [],
-        parsedLabels,
-    };
-}
+export { isKnownIssueRoutingLabel, resolveIssueRepositories } from 'doistbot-issue-routing';

package/sandbox/dist/providers/config.js

@@ -1,4 +1,4 @@
-const DEFAULT_PROVIDER_TIMEOUT_MS = 10 * 60 * 1000;
+export const DEFAULT_PROVIDER_TIMEOUT_MS = 10 * 60 * 1000;
 function parseTimeoutMs(value) {
     if (!value) {
         return null;

package/sandbox/dist/providers/helpers.js

@@ -141,6 +141,9 @@ export function parseRawFindings(comments, modelName) {
             side,
             body: comment.body.trim(),
             sourceModel: modelName,
+            ...(comment.translationResolution
+                ? { translationResolution: comment.translationResolution }
+                : {}),
         };
     });
 }

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

@@ -1,13 +1,21 @@
 import { logger } from '../core/logging.js';
-import { createPiInvoker, parsePiAuthProviderId, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../core/pi.js';
+import { createPiInvoker, parsePiAuthProviderId, PI_PROVIDER_BY_DOISTBOT_PROVIDER, toPiInvocationTelemetryFields, } from '../core/pi.js';
 import { logPiProgressEvent } from '../core/pi-progress-logging.js';
 import { WORKSPACE_DIR } from '../core/shared.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, }) {
+function buildModelFailureResult({ model, error, durationMs, timedOut = false, telemetry, }) {
     return {
         model,
         summary: '',
@@ -15,9 +23,36 @@ function buildModelFailureResult({ model, error, durationMs, timedOut = false, }
         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: {
@@ -61,10 +96,11 @@ export async function runPiReviewProvider(params) {
 }
 async function runPiReviewProviderCore({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, }) {
     const startTime = Date.now();
-    const timeoutMs = config.timeout ?? 0;
+    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,
@@ -89,6 +125,7 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
             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({
@@ -97,6 +134,7 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
                 timeoutMs,
             });
             const durationMs = Date.now() - startTime;
+            latestTelemetry = result.telemetry;
             stdout = result.ok ? result.output : '';
             stderr = result.ok ? '' : result.error;
             status = result.ok ? 0 : null;
@@ -108,6 +146,13 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
                 attemptDurationMs: result.durationMs,
                 toolUsage: result.toolUsage,
             });
+            logReviewLatency({
+                provider,
+                modelName,
+                attempt: attempt + 1,
+                attemptsTotal: prompts.length,
+                result,
+            });
             if (!result.ok && result.timedOut) {
                 logReviewRawModelOutput({
                     model: provider,
@@ -130,6 +175,7 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
                     error,
                     durationMs,
                     timedOut: true,
+                    telemetry: result.telemetry,
                 });
             }
             if (!result.ok) {
@@ -153,6 +199,7 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
                     model: provider,
                     error,
                     durationMs,
+                    telemetry: result.telemetry,
                 });
             }
             const output = result.output;
@@ -170,6 +217,7 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
                     model: provider,
                     error: `Empty response from Pi ${provider} request`,
                     durationMs,
+                    telemetry: result.telemetry,
                 });
             }
             try {
@@ -202,6 +250,7 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
                     summary: normalized.summary,
                     findings: normalized.findings,
                     durationMs,
+                    telemetry: result.telemetry,
                 };
             }
             catch (error) {
@@ -246,6 +295,7 @@ async function runPiReviewProviderCore({ provider, modelName, prompt, config, pr
             error: errorMessage,
             durationMs,
             timedOut: errorMessage.toLowerCase().includes('timed out'),
+            telemetry: latestTelemetry,
         });
     }
 }

package/sandbox/dist/providers/schemas.js

@@ -1,4 +1,5 @@
 import { Ajv } from 'ajv';
+import { TRANSLATION_RESOLUTIONS } from './types.js';
 export const REVIEW_SCHEMA = {
     type: 'object',
     additionalProperties: false,
@@ -14,7 +15,13 @@ export const REVIEW_SCHEMA = {
                     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'],
             },
         },

package/sandbox/dist/providers/types.js

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