@doist/doistbot-cli 1.0.4 → 1.0.5

package/sandbox/dist/tasks/review/council/voter.js

@@ -1,384 +0,0 @@
-/**
- * Voter module for achieving consensus on findings across multiple models.
- * Each model votes on findings from OTHER models (no self-voting).
- */
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { logger } from '../../../core/logging.js';
-import { WORKSPACE_DIR } from '../../../core/shared.js';
-import { getProvider } from '../../../providers/index.js';
-import { BATCH_VOTE_SCHEMA, isBatchVoteResponse } from '../../../providers/schemas.js';
-import { loadStandardsSection } from '../prompt.js';
-import { getReviewThinkingLevel } from '../thinking-level.js';
-import { DeliveryProviderHealthTracker } from './provider-health.js';
-const CONSENSUS_THRESHOLD = 0.67; // 2/3 approval required
-const REVIEW_TASK_DIR = path.dirname(fileURLToPath(import.meta.url));
-const VOTE_PROMPT_FILE_CANDIDATES = [
-    path.resolve(REVIEW_TASK_DIR, '../../../vote-prompt.md'),
-    path.resolve(REVIEW_TASK_DIR, '../../../../vote-prompt.md'),
-];
-function resolveVotePromptFile() {
-    const promptFile = VOTE_PROMPT_FILE_CANDIDATES.find((candidate) => fs.existsSync(candidate));
-    if (!promptFile) {
-        throw new Error(`Unable to find vote prompt template. Checked: ${VOTE_PROMPT_FILE_CANDIDATES.join(', ')}`);
-    }
-    return promptFile;
-}
-/**
- * Loads the voting prompt template.
- */
-function loadVotePromptTemplate() {
-    const votePromptFile = resolveVotePromptFile();
-    try {
-        return fs.readFileSync(votePromptFile, 'utf8');
-    }
-    catch (error) {
-        logger.error('Failed to load vote prompt template', {
-            path: votePromptFile,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        throw error;
-    }
-}
-/**
- * Builds the serialized block for a finding in a batched vote prompt.
- */
-function buildFindingVoteBlock(finding, codeContext) {
-    return [
-        '<finding>',
-        `<finding_id>${finding.id}</finding_id>`,
-        `<file_path>${finding.path}</file_path>`,
-        `<line_number>${finding.line}</line_number>`,
-        `<side>${finding.side}</side>`,
-        '<finding_body>',
-        finding.body,
-        '</finding_body>',
-        '<code_context>',
-        '```',
-        codeContext,
-        '```',
-        '</code_context>',
-        '</finding>',
-    ].join('\n');
-}
-/**
- * Builds a voting prompt for a batch of findings assigned to one voter.
- */
-function buildVotePrompt(groups, workspaceDir) {
-    const template = loadVotePromptTemplate();
-    const findingsBlock = groups
-        .map((group) => buildFindingVoteBlock(group.primaryFinding, getCodeContext(group.primaryFinding, workspaceDir)))
-        .join('\n\n');
-    return template
-        .replace('$FINDINGS', () => findingsBlock)
-        .replace('$STANDARDS_SECTION', () => loadStandardsSection());
-}
-/**
- * Gets code context around a finding from the workspace.
- */
-function getWorkspaceDir(workspaceDir) {
-    return workspaceDir ?? WORKSPACE_DIR;
-}
-function getCodeContext(finding, workspaceDir, contextLines = 10) {
-    try {
-        const filePath = path.join(getWorkspaceDir(workspaceDir), finding.path);
-        if (!fs.existsSync(filePath)) {
-            return '[File not found in workspace]';
-        }
-        const content = fs.readFileSync(filePath, 'utf8');
-        const lines = content.split('\n');
-        const startLine = Math.max(0, finding.line - contextLines - 1);
-        const endLine = Math.min(lines.length, finding.line + contextLines);
-        const contextWithLineNumbers = lines
-            .slice(startLine, endLine)
-            .map((line, idx) => {
-            const lineNum = startLine + idx + 1;
-            const marker = lineNum === finding.line ? '>>> ' : '    ';
-            return `${marker}${lineNum}: ${line}`;
-        })
-            .join('\n');
-        return contextWithLineNumbers;
-    }
-    catch (error) {
-        logger.warn('Failed to get code context for voting', {
-            finding: finding.id,
-            path: finding.path,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return '[Error reading file]';
-    }
-}
-/**
- * Has a single model vote on a batch of findings.
- */
-async function getVotesForVoter(voter, groups, apiKeys, workspaceDir, providerHealth) {
-    const apiKey = apiKeys[voter];
-    if (!apiKey) {
-        logger.warn('Council vote batch skipped - no API key', {
-            voter,
-            findingsCount: groups.length,
-        });
-        return [];
-    }
-    const prompt = buildVotePrompt(groups, workspaceDir);
-    const provider = getProvider(voter);
-    const config = {
-        apiKey,
-        workspaceDir,
-        jsonSchema: BATCH_VOTE_SCHEMA,
-        thinkingLevel: getReviewThinkingLevel(voter),
-    };
-    const expectedFindingIds = new Set(groups.map((group) => group.primaryFinding.id));
-    logger.info('Council vote batch requested', {
-        voter,
-        findingsCount: groups.length,
-        findingIds: groups.map((group) => group.primaryFinding.id),
-    });
-    try {
-        const result = await provider.review(prompt, config);
-        if (result.error) {
-            providerHealth.recordFailure({
-                provider: voter,
-                stage: 'vote',
-                error: result.error,
-                timedOut: result.timedOut,
-            });
-            logger.error('Council vote batch failed', {
-                voter,
-                findingsCount: groups.length,
-                error: result.error,
-            });
-            return [];
-        }
-        if (!isBatchVoteResponse(result.structuredOutput)) {
-            throw new Error('Could not parse batch vote response from structured output');
-        }
-        const batchVoteResponse = result.structuredOutput;
-        const parseMethod = 'structured_output';
-        const votesByFindingId = new Map();
-        const unexpectedFindingIds = [];
-        for (const decision of batchVoteResponse.votes) {
-            if (!expectedFindingIds.has(decision.findingId)) {
-                unexpectedFindingIds.push(decision.findingId);
-                continue;
-            }
-            if (votesByFindingId.has(decision.findingId)) {
-                continue;
-            }
-            const vote = {
-                voter,
-                findingId: decision.findingId,
-                approve: Boolean(decision.approve),
-                confidence: Math.max(0, Math.min(1, decision.confidence ?? 0.5)),
-                reasoning: typeof decision.reasoning === 'string' ? decision.reasoning : '',
-            };
-            votesByFindingId.set(decision.findingId, vote);
-            logger.info('Council vote received', {
-                voter,
-                findingId: vote.findingId,
-                vote: vote.approve,
-                confidence: vote.confidence,
-                parseMethod,
-                reasoning: vote.reasoning,
-            });
-        }
-        if (unexpectedFindingIds.length > 0) {
-            logger.error('Council vote batch included unexpected finding ids', {
-                voter,
-                unexpectedFindingIds,
-            });
-            return [];
-        }
-        const missingFindingIds = groups
-            .map((group) => group.primaryFinding.id)
-            .filter((findingId) => !votesByFindingId.has(findingId));
-        if (missingFindingIds.length > 0) {
-            logger.error('Council vote batch missing decisions', {
-                voter,
-                missingFindingIds,
-            });
-        }
-        logger.info('Council vote batch received', {
-            voter,
-            findingsCount: groups.length,
-            votesCount: votesByFindingId.size,
-            parseMethod,
-        });
-        return [...votesByFindingId.values()];
-    }
-    catch (error) {
-        logger.error('Council vote batch failed', {
-            voter,
-            findingsCount: groups.length,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return [];
-    }
-}
-/**
- * Batches voting so each eligible voter reviews all of its assigned findings in one call.
- */
-async function collectVotesForGroups(groups, availableModels, apiKeys, workspaceDir, providerHealth) {
-    const votesByFindingId = new Map();
-    const voters = providerHealth.getHealthyProviders(availableModels, {
-        stage: 'vote',
-    });
-    const votePromises = voters.map((voter) => {
-        const eligibleGroups = groups.filter((group) => !group.sourceModels.includes(voter));
-        if (eligibleGroups.length === 0) {
-            return Promise.resolve([]);
-        }
-        return getVotesForVoter(voter, eligibleGroups, apiKeys, workspaceDir, providerHealth);
-    });
-    const voteResults = await Promise.allSettled(votePromises);
-    for (const result of voteResults) {
-        if (result.status !== 'fulfilled') {
-            continue;
-        }
-        for (const vote of result.value) {
-            const findingVotes = votesByFindingId.get(vote.findingId) ?? [];
-            findingVotes.push(vote);
-            votesByFindingId.set(vote.findingId, findingVotes);
-        }
-    }
-    return votesByFindingId;
-}
-function isAutoApprovedGroup(group, availableModels) {
-    return (availableModels.length > 0 &&
-        availableModels.every((model) => group.sourceModels.includes(model)));
-}
-function getEligibleVoters(group, availableModels) {
-    return availableModels.filter((model) => !group.sourceModels.includes(model));
-}
-/**
- * Calculates consensus for a finding group.
- * Uses the primary finding for voting, applies result to the group.
- * All approvals must be explicit - no implicit approvals based on who found the issue.
- */
-function calculateConsensusForGroup(group, votes, threshold) {
-    const finding = group.primaryFinding;
-    const approvals = votes.filter((v) => v.approve).length;
-    const approvalRatio = votes.length > 0 ? approvals / votes.length : 0;
-    const isApproved = approvalRatio >= threshold;
-    const consensusResult = {
-        findingId: finding.id,
-        finding,
-        approvalRatio,
-        isApproved,
-        votes,
-    };
-    logger.info('Council consensus result', {
-        findingId: finding.id,
-        approvalRatio,
-        isApproved,
-        votes: votes.map((v) => ({
-            voter: v.voter,
-            approve: v.approve,
-            confidence: v.confidence,
-        })),
-        sourceModels: group.sourceModels,
-    });
-    return consensusResult;
-}
-function buildAutoApprovedConsensusResult(group) {
-    const consensusResult = {
-        findingId: group.primaryFinding.id,
-        finding: group.primaryFinding,
-        approvalRatio: 1,
-        isApproved: true,
-        votes: [],
-    };
-    logger.info('Council consensus result', {
-        findingId: group.primaryFinding.id,
-        approvalRatio: 1,
-        isApproved: true,
-        votes: [],
-        sourceModels: group.sourceModels,
-    });
-    return consensusResult;
-}
-function buildSingleVoterFailOpenConsensusResult(group, eligibleVoter) {
-    const consensusResult = {
-        findingId: group.primaryFinding.id,
-        finding: group.primaryFinding,
-        approvalRatio: 1,
-        isApproved: true,
-        votes: [],
-    };
-    logger.warn('Failing open for finding after sole voter failure', {
-        findingId: group.primaryFinding.id,
-        sourceModels: group.sourceModels,
-        eligibleVoter,
-    });
-    logger.info('Council consensus result', {
-        findingId: group.primaryFinding.id,
-        approvalRatio: 1,
-        isApproved: true,
-        votes: [],
-        sourceModels: group.sourceModels,
-        failOpen: true,
-        eligibleVoter,
-    });
-    return consensusResult;
-}
-export async function runVoting({ findingGroups, availableModels, apiKeys, workspaceDir, providerHealth = new DeliveryProviderHealthTracker(), }) {
-    if (findingGroups.length === 0) {
-        return [];
-    }
-    if (availableModels.length < 2) {
-        logger.warn('Less than 2 models available for voting, skipping consensus', {
-            availableModels,
-        });
-        // If we can't achieve meaningful consensus, approve all findings
-        return findingGroups.map((group) => ({
-            findingId: group.primaryFinding.id,
-            finding: group.primaryFinding,
-            approvalRatio: 1.0,
-            isApproved: true,
-            votes: [],
-        }));
-    }
-    logger.info('Council voting started', {
-        findingGroupsCount: findingGroups.length,
-        availableModels,
-        threshold: CONSENSUS_THRESHOLD,
-    });
-    const pendingGroups = findingGroups.filter((group) => !isAutoApprovedGroup(group, availableModels));
-    const votesByFindingId = await collectVotesForGroups(pendingGroups, availableModels, apiKeys, workspaceDir, providerHealth);
-    const consensusResults = findingGroups.map((group) => {
-        if (isAutoApprovedGroup(group, availableModels)) {
-            return buildAutoApprovedConsensusResult(group);
-        }
-        const votes = votesByFindingId.get(group.primaryFinding.id) ?? [];
-        const eligibleVoters = getEligibleVoters(group, availableModels);
-        const onlyEligibleVoter = eligibleVoters[0];
-        if (votes.length === 0 && eligibleVoters.length === 1 && onlyEligibleVoter) {
-            return buildSingleVoterFailOpenConsensusResult(group, onlyEligibleVoter);
-        }
-        return calculateConsensusForGroup(group, votes, CONSENSUS_THRESHOLD);
-    });
-    for (const group of pendingGroups) {
-        const votes = votesByFindingId.get(group.primaryFinding.id) ?? [];
-        const eligibleVoters = getEligibleVoters(group, availableModels);
-        if (votes.length > 0 || eligibleVoters.length === 1) {
-            continue;
-        }
-        logger.warn('No voters available for finding', {
-            findingId: group.primaryFinding.id,
-            sourceModels: group.sourceModels,
-        });
-    }
-    logger.info('Council voting completed', {
-        totalGroups: findingGroups.length,
-        approved: consensusResults.filter((r) => r.isApproved).length,
-        rejected: consensusResults.filter((r) => !r.isApproved).length,
-    });
-    return consensusResults;
-}
-/**
- * Filters consensus results to only return approved findings.
- */
-export function getApprovedFindings(consensusResults) {
-    return consensusResults.filter((r) => r.isApproved).map((r) => r.finding);
-}

package/sandbox/dist/tasks/review/engines/council.js

@@ -1,126 +0,0 @@
-import { runCouncilReview } from '../council/orchestrator.js';
-import { buildReviewOutputFromFindings, getApiKeys, getAvailableModels, getProviderFailures, requestModelReview, } from './shared.js';
-async function runSingleModelReview({ prompt, lineLookup, prTitle, prBody, prAuthor, prAuthorGreetingName, resolvePrAuthorGreetingName, excludePrAuthorFromSummary, workspaceDir, apiKeys, onProgress, }) {
-    const availableModels = getAvailableModels(apiKeys);
-    const model = availableModels[0];
-    if (!model) {
-        return { review: null, providerFailures: [] };
-    }
-    const reviewResult = await requestModelReview({
-        model,
-        prompt,
-        apiKeys,
-        workspaceDir,
-        onProgress,
-    });
-    if (!reviewResult || reviewResult.error) {
-        return {
-            review: null,
-            providerFailures: reviewResult
-                ? getProviderFailures([reviewResult])
-                : [{ model, error: `No review result returned for ${model}` }],
-        };
-    }
-    return {
-        review: await buildReviewOutputFromFindings({
-            commentsSource: reviewResult.findings,
-            lineLookup,
-            prTitle,
-            prBody,
-            prAuthor,
-            prAuthorGreetingName,
-            resolvePrAuthorGreetingName,
-            excludePrAuthorFromSummary,
-            summaryApiKey: apiKeys.gemini,
-            workspaceDir,
-            preferredSummary: reviewResult.summary,
-        }),
-        providerFailures: [],
-    };
-}
-async function runMultiModelReview({ ctx, prompt, lineLookup, prTitle, prBody, prAuthor, prAuthorGreetingName, resolvePrAuthorGreetingName, excludePrAuthorFromSummary, apiKeys, onProgress, }) {
-    const result = await runCouncilReview({
-        prompt,
-        apiKeys,
-        repository: `${ctx.owner}/${ctx.repo}`,
-        prNumber: ctx.prNumber,
-        workspaceDir: ctx.workspaceDir,
-        onProgress,
-    });
-    if (result.errors.length > 0 && result.modelsUsed.length === 0) {
-        return { review: null, providerFailures: result.errors };
-    }
-    return {
-        review: await buildReviewOutputFromFindings({
-            commentsSource: result.approvedFindings,
-            lineLookup,
-            prTitle,
-            prBody,
-            prAuthor,
-            prAuthorGreetingName,
-            resolvePrAuthorGreetingName,
-            excludePrAuthorFromSummary,
-            summaryApiKey: apiKeys.gemini,
-            workspaceDir: ctx.workspaceDir,
-        }),
-        providerFailures: result.errors,
-    };
-}
-export async function runCouncilReviewEngine({ ctx, prompt, lineLookup, prTitle, prBody, prAuthor, prAuthorGreetingName, resolvePrAuthorGreetingName, excludePrAuthorFromSummary, onProgress, standardsSection: _standardsSection, }) {
-    const apiKeys = getApiKeys(ctx);
-    const availableModels = getAvailableModels(apiKeys);
-    let metricModels = [];
-    if (availableModels.length > 0) {
-        metricModels =
-            ctx.councilEnabled && availableModels.length >= 2
-                ? [...availableModels]
-                : [availableModels[0]];
-    }
-    else if (ctx.councilModelsEnabled.length > 0) {
-        metricModels = [...ctx.councilModelsEnabled];
-    }
-    if (availableModels.length === 0) {
-        return {
-            review: null,
-            availableModels,
-            metricModels,
-            mode: 'single',
-            providerFailures: [],
-        };
-    }
-    const useCouncil = ctx.councilEnabled && availableModels.length >= 2;
-    const { review, providerFailures } = useCouncil
-        ? await runMultiModelReview({
-            ctx,
-            prompt,
-            lineLookup,
-            prTitle,
-            prBody,
-            prAuthor,
-            prAuthorGreetingName,
-            resolvePrAuthorGreetingName,
-            excludePrAuthorFromSummary,
-            apiKeys,
-            onProgress,
-        })
-        : await runSingleModelReview({
-            prompt,
-            lineLookup,
-            prTitle,
-            prBody,
-            prAuthor,
-            prAuthorGreetingName,
-            resolvePrAuthorGreetingName,
-            excludePrAuthorFromSummary,
-            workspaceDir: ctx.workspaceDir,
-            apiKeys,
-            onProgress,
-        });
-    return {
-        review,
-        availableModels,
-        metricModels,
-        mode: useCouncil ? 'council' : 'single',
-        providerFailures,
-    };
-}

package/sandbox/dist/tasks/review/engines/index.js

@@ -1,12 +0,0 @@
-import { runCouncilReviewEngine } from './council.js';
-import { runMultiFocusReviewEngine } from './multi-focus.js';
-export function getReviewEngineRunner(engine) {
-    switch (engine) {
-        case 'council':
-            return runCouncilReviewEngine;
-        case 'multi_focus':
-            return runMultiFocusReviewEngine;
-        default:
-            throw new Error(`Unsupported review engine: ${engine}`);
-    }
-}

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

@@ -1,5 +0,0 @@
-import { DEFAULT_REVIEW_ENGINE, parseReviewEngine as parseSharedReviewEngine, } from 'doistbot-repo-config';
-export { DEFAULT_REVIEW_ENGINE };
-export function parseReviewEngine(raw) {
-    return parseSharedReviewEngine(raw) ?? DEFAULT_REVIEW_ENGINE;
-}

package/sandbox/node_modules/doistbot-repo-config/dist/review-engine.d.ts

@@ -1,11 +0,0 @@
-export declare const DEFAULT_REVIEW_ENGINE: "multi_focus";
-export type ReviewEngine = 'council' | 'multi_focus';
-export declare function parseReviewEngine(raw: unknown): ReviewEngine | null;
-export declare function resolveReviewEngine({ configuredEngine, envEngine, logger, repository, }: {
-    configuredEngine?: unknown;
-    envEngine?: unknown;
-    logger?: {
-        warn: (message: string, context?: Record<string, unknown>) => void;
-    };
-    repository?: string;
-}): ReviewEngine;

package/sandbox/node_modules/doistbot-repo-config/dist/review-engine.js

@@ -1,41 +0,0 @@
-export const DEFAULT_REVIEW_ENGINE = 'multi_focus';
-function isReviewEngine(value) {
-    return value === 'council' || value === 'multi_focus';
-}
-export function parseReviewEngine(raw) {
-    if (typeof raw !== 'string') {
-        return null;
-    }
-    const normalized = raw.trim().toLowerCase();
-    if (!normalized) {
-        return null;
-    }
-    return isReviewEngine(normalized) ? normalized : null;
-}
-export function resolveReviewEngine({ configuredEngine, envEngine, logger, repository, }) {
-    const configured = parseReviewEngine(configuredEngine);
-    if (configured) {
-        return configured;
-    }
-    if (configuredEngine != null) {
-        logger?.warn('Invalid configured review engine, checking environment override next', {
-            component: 'review-engine',
-            repository,
-            configured_engine: configuredEngine,
-            next_source: 'env',
-        });
-    }
-    const fromEnv = parseReviewEngine(envEngine);
-    if (fromEnv) {
-        return fromEnv;
-    }
-    if (envEngine != null) {
-        logger?.warn('Invalid env review engine, falling back', {
-            component: 'review-engine',
-            repository,
-            env_engine: envEngine,
-            fallback: DEFAULT_REVIEW_ENGINE,
-        });
-    }
-    return DEFAULT_REVIEW_ENGINE;
-}