@doist/doistbot-cli 1.0.1 → 1.0.3

package/dist/actions/review-usage.js

@@ -0,0 +1,20 @@
+const REVIEW_USAGE_COMMANDS = ['doistbot review [staged]', 'db review [staged]'];
+const REVIEW_SETUP_COMMANDS = [
+    'doistbot review',
+    'doistbot review staged',
+    'db review',
+    'db review staged',
+];
+export function formatReviewUsage() {
+    return `Usage: ${formatCommandList(REVIEW_USAGE_COMMANDS)}`;
+}
+export function formatSetupCompleteMessage() {
+    return `Setup complete. Run ${formatCommandList(REVIEW_SETUP_COMMANDS)} from a git repository.`;
+}
+function formatCommandList(commands) {
+    const quotedCommands = commands.map((command) => `\`${command}\``);
+    if (quotedCommands.length <= 2) {
+        return quotedCommands.join(' or ');
+    }
+    return `${quotedCommands.slice(0, -1).join(', ')}, or ${quotedCommands.at(-1)}`;
+}

package/dist/actions/review.js

@@ -1,7 +1,9 @@
 import { getApiKeys } from '../config.js';
 import { getRepositoryRoot, loadSandboxFormatModule, loadSandboxReviewModule } from '../runtime.js';
 import { formatReviewProgress, renderAlert, renderMarkdown, withSpinner, writeLine, } from '../terminal.js';
+import { formatReviewUsage } from './review-usage.js';
 const LOCAL_REVIEW_SOURCE_STAGED = 'staged';
+const JSON_SCHEMA_VERSION = 1;
 const PROVIDER_DISPLAY_NAMES = {
     gemini: 'Gemini',
     openai: 'OpenAI Codex',
@@ -41,14 +43,17 @@ function getReadableProviderFailure(failure) {
         ?.trim();
     return `${PROVIDER_DISPLAY_NAMES[failure.model]} failed: ${firstLine || 'unknown error'}`;
 }
-function getReadableProviderFailures(failures) {
+function getReadableProviderFailureEntries(failures) {
     const messagesByModel = new Map();
     for (const failure of failures) {
         if (!messagesByModel.has(failure.model)) {
             messagesByModel.set(failure.model, getReadableProviderFailure(failure));
         }
     }
-    return [...messagesByModel.values()];
+    return Array.from(messagesByModel, ([model, message]) => ({ model, message }));
+}
+function getReadableProviderFailures(failures) {
+    return getReadableProviderFailureEntries(failures).map(({ message }) => message);
 }
 function formatProviderFailureMessage(failures) {
     const messages = getReadableProviderFailures(failures);
@@ -86,19 +91,130 @@ function handleSkippedReview(result) {
 function formatReviewOutput({ formatReviewForTerminal, review, }) {
     return formatReviewForTerminal({ review });
 }
-export async function runReview(sourceArg) {
-    if (sourceArg !== undefined && sourceArg !== LOCAL_REVIEW_SOURCE_STAGED) {
-        throw new Error('Usage: doistbot review [staged]');
+function getJsonStatus(result) {
+    function mapping(statusMapping, canTrustCleanReview = statusMapping.status === 'reviewed') {
+        return { mapping: statusMapping, canTrustCleanReview };
     }
-    const source = sourceArg === LOCAL_REVIEW_SOURCE_STAGED ? LOCAL_REVIEW_SOURCE_STAGED : 'base';
+    if (result.reviewResult.status === 'skipped') {
+        switch (result.reviewResult.reason) {
+            case 'empty_review':
+            case 'no_models':
+            case 'no_review':
+                return mapping({
+                    status: 'unverified',
+                    verified: false,
+                    unverifiedReason: result.reviewResult.reason,
+                }, false);
+            default:
+                return mapping({
+                    status: 'skipped',
+                    verified: false,
+                    skipReason: result.reviewResult.reason,
+                }, false);
+        }
+    }
+    return mapping({ status: 'reviewed', verified: true });
+}
+function finalizeJsonStatus({ initialStatus, findingCount, providerFailureCount, }) {
+    if (initialStatus.canTrustCleanReview && providerFailureCount > 0 && findingCount === 0) {
+        return { status: 'unverified', verified: false, unverifiedReason: 'provider_failures' };
+    }
+    return initialStatus.mapping;
+}
+function getReviewForJson(result) {
+    if (result.reviewResult.status === 'reviewed') {
+        return result.reviewResult.review;
+    }
+    return { summary: '', comments: [] };
+}
+function hasLocation(finding) {
+    return typeof finding.path === 'string' && typeof finding.line === 'number';
+}
+function formatReviewJsonFinding(finding) {
+    return {
+        body: finding.body,
+        severity: finding.severity,
+        ...(hasLocation(finding)
+            ? {
+                location: {
+                    path: finding.path,
+                    line: finding.line,
+                    ...(finding.side ? { side: finding.side } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function getReviewFindingsForJson(review) {
+    if (review.findings) {
+        return review.findings;
+    }
+    return review.comments.map((comment) => ({
+        body: comment.body,
+        severity: null,
+        placement: 'inline',
+        path: comment.path,
+        line: comment.line,
+        side: comment.side,
+    }));
+}
+function getReviewFindingCount(review) {
+    return getReviewFindingsForJson(review).length;
+}
+function formatReviewForJson(result) {
+    const review = getReviewForJson(result);
+    const reviewFindings = getReviewFindingsForJson(review);
+    const findings = reviewFindings.map(formatReviewJsonFinding);
+    const statusMapping = finalizeJsonStatus({
+        initialStatus: getJsonStatus(result),
+        findingCount: findings.length,
+        providerFailureCount: result.reviewResult.providerFailures.length,
+    });
+    return {
+        schemaVersion: JSON_SCHEMA_VERSION,
+        ...statusMapping,
+        reviewSource: result.source,
+        repository: {
+            owner: result.owner,
+            repo: result.repo,
+            branch: result.branch,
+            baseBranch: result.baseBranch,
+        },
+        review: {
+            count: findings.length,
+            findings,
+        },
+        providerFailures: getReadableProviderFailureEntries(result.reviewResult.providerFailures),
+    };
+}
+async function runLocalReviewForCli({ source, onProgress, }) {
     const reviewModule = await loadSandboxReviewModule();
-    const result = await withSpinner(source === LOCAL_REVIEW_SOURCE_STAGED
-        ? 'Reviewing staged changes...'
-        : 'Reviewing local changes...', async (status) => await reviewModule.runLocalReview({
+    return await reviewModule.runLocalReview({
         workspaceDir: getRepositoryRoot(),
         source,
         apiKeys: await getApiKeys(),
         suppressLogs: true,
+        onProgress,
+    });
+}
+export async function runReview(sourceArg, options = {}) {
+    if (sourceArg !== undefined && sourceArg !== LOCAL_REVIEW_SOURCE_STAGED) {
+        throw new Error(formatReviewUsage());
+    }
+    const source = sourceArg === LOCAL_REVIEW_SOURCE_STAGED ? LOCAL_REVIEW_SOURCE_STAGED : 'base';
+    if (options.json === true) {
+        const result = await runLocalReviewForCli({ source });
+        const output = formatReviewForJson(result);
+        writeLine(JSON.stringify(output, null, 2));
+        if (output.status === 'unverified') {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const result = await withSpinner(source === LOCAL_REVIEW_SOURCE_STAGED
+        ? 'Reviewing staged changes...'
+        : 'Reviewing local changes...', async (status) => await runLocalReviewForCli({
+        source,
         onProgress: status.enabled
             ? (event) => status.update(formatReviewProgress(event))
             : undefined,
@@ -109,7 +225,7 @@ export async function runReview(sourceArg) {
     }
     const formatModule = await loadSandboxFormatModule();
     if (result.reviewResult.providerFailures.length > 0 &&
-        result.reviewResult.review.comments.length === 0) {
+        getReviewFindingCount(result.reviewResult.review) === 0) {
         throw new Error(formatProviderFailureMessage(result.reviewResult.providerFailures));
     }
     const output = formatReviewOutput({

package/dist/actions/setup.js

@@ -1,13 +1,14 @@
 import { checkGit, checkPiDependency, checkSandboxBuild } from '../runtime.js';
 import { renderDiagnosticCheck, writeLine } from '../terminal.js';
 import { runAuthSetup } from './auth.js';
+import { formatSetupCompleteMessage } from './review-usage.js';
 export async function runSetup() {
-    writeLine('Checking DoistBot CLI prerequisites...');
+    writeLine('Checking Doistbot CLI prerequisites...');
     await renderDiagnosticCheck('git', checkGit);
     await renderDiagnosticCheck('pi', checkPiDependency);
     await renderDiagnosticCheck('sandbox build', checkSandboxBuild);
     writeLine();
     await runAuthSetup();
     writeLine();
-    writeLine('Setup complete. Run `doistbot review` or `doistbot review staged` from a git repository.');
+    writeLine(formatSetupCompleteMessage());
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { AUTH_LOGOUT_PROVIDER_USAGE, runAuthLogout, runAuthSetup, runAuthStatus, } from './actions/auth.js';
 import { runDoctor } from './actions/doctor.js';
 import { runReview } from './actions/review.js';
@@ -34,18 +34,27 @@ export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAu
         automaticUpdateCommands.add(command);
         return command;
     }
+    function shouldRunAutomaticUpdateCheck(actionCommand) {
+        if (!automaticUpdateCommands.has(actionCommand)) {
+            return false;
+        }
+        if (actionCommand.name() === 'review' && actionCommand.opts().json) {
+            return false;
+        }
+        return true;
+    }
     program
         .name('doistbot')
-        .description('DoistBot local self-review CLI')
+        .description('Doistbot local self-review CLI')
         .version(PACKAGE_VERSION)
         .hook('postAction', async (_thisCommand, actionCommand) => {
-        if (automaticUpdateCommands.has(actionCommand)) {
+        if (shouldRunAutomaticUpdateCheck(actionCommand)) {
             await automaticUpdateCheck();
         }
     });
     withAutomaticUpdateCheck(program
         .command('doctor')
-        .description('Diagnose local DoistBot CLI setup')
+        .description('Diagnose local Doistbot CLI setup')
         .action(async () => await doctor()));
     withAutomaticUpdateCheck(program
         .command('setup')
@@ -53,7 +62,7 @@ export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAu
         .action(async () => await setup()));
     const authCommand = withAutomaticUpdateCheck(program
         .command('auth')
-        .description('Authenticate DoistBot CLI with local review providers')
+        .description('Authenticate Doistbot CLI with local review providers')
         .action(async () => await authSetup()));
     withAutomaticUpdateCheck(authCommand
         .command('status')
@@ -65,15 +74,16 @@ export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAu
         .action(async () => await authSetup()));
     withAutomaticUpdateCheck(authCommand
         .command('logout [provider]')
-        .description(`Clear stored DoistBot CLI auth for ${AUTH_LOGOUT_PROVIDER_USAGE}`)
+        .description(`Clear stored Doistbot CLI auth for ${AUTH_LOGOUT_PROVIDER_USAGE}`)
         .action(async (provider) => await authLogout(provider)));
     withAutomaticUpdateCheck(program
         .command('review [source]')
         .description('Run a local self-review. Use `staged` to review only staged changes.')
-        .action(async (source) => await review(source)));
+        .addOption(new Option('--json', 'Print machine-readable JSON instead of terminal-formatted markdown').hideHelp())
+        .action(async (source, options) => await review(source, { json: options?.json === true })));
     program
         .command('update')
-        .description('Check whether a newer DoistBot CLI version is available')
+        .description('Check whether a newer Doistbot CLI version is available')
         .action(async () => await updateCheck());
     return program;
 }

package/dist/runtime.js

@@ -53,10 +53,10 @@ async function loadBundledModule(modulePath, missingMessage) {
     return (await import(pathToFileURL(modulePath).href));
 }
 export async function loadSandboxReviewModule() {
-    return loadBundledModule(getSandboxReviewModulePath(), 'Sandbox review runner is missing. Rebuild or reinstall the DoistBot CLI package.');
+    return loadBundledModule(getSandboxReviewModulePath(), 'Sandbox review runner is missing. Rebuild or reinstall the Doistbot CLI package.');
 }
 export async function loadSandboxFormatModule() {
-    return loadBundledModule(getSandboxFormatModulePath(), 'Sandbox review formatter is missing. Rebuild or reinstall the DoistBot CLI package.');
+    return loadBundledModule(getSandboxFormatModulePath(), 'Sandbox review formatter is missing. Rebuild or reinstall the Doistbot CLI package.');
 }
 export function runGit(args, cwd = process.cwd()) {
     return execFileSync('git', args, {
@@ -89,7 +89,7 @@ export function checkSandboxBuild() {
     const modulePath = getSandboxReviewModulePath();
     return fs.existsSync(modulePath)
         ? { ok: true, message: 'sandbox review runner is built' }
-        : { ok: false, message: 'rebuild or reinstall the DoistBot CLI package' };
+        : { ok: false, message: 'rebuild or reinstall the Doistbot CLI package' };
 }
 export function checkPiDependency() {
     try {

package/dist/update-check.js

@@ -38,7 +38,7 @@ export async function notifyIfCliUpdateAvailable({ cachePath = getDefaultUpdateC
         timeoutMs,
     });
     if (!latestVersion) {
-        write('Unable to check for DoistBot CLI updates.');
+        write('Unable to check for Doistbot CLI updates.');
         return;
     }
     if (!isNewerVersion(latestVersion, currentVersion)) {

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "@doist/doistbot-cli",
-    "version": "1.0.1",
-    "description": "Local self-review CLI for DoistBot",
+    "version": "1.0.3",
+    "description": "Local self-review CLI for Doistbot",
     "type": "module",
     "main": "dist/index.js",
     "bin": {
+        "db": "dist/index.js",
         "doistbot": "dist/index.js"
     },
     "keywords": [
@@ -41,8 +42,8 @@
     "dependencies": {
         "@inquirer/checkbox": "5.1.5",
         "@inquirer/password": "5.0.13",
-        "@mariozechner/pi-ai": "0.73.0",
-        "@mariozechner/pi-coding-agent": "0.73.0",
+        "@mariozechner/pi-ai": "0.73.1",
+        "@mariozechner/pi-coding-agent": "0.73.1",
         "@napi-rs/keyring": "1.3.0",
         "ajv": "8.20.0",
         "chalk": "4.1.2",
@@ -52,6 +53,6 @@
         "yocto-spinner": "1.2.0"
     },
     "devDependencies": {
-        "vitest": "4.1.5"
+        "vitest": "4.1.6"
     }
 }

package/sandbox/_node_modules/doistbot-repo-config/dist/index.d.ts

@@ -28,6 +28,7 @@ export type RepoConfig = {
     issue_triage?: {
         enable_auto_triage?: boolean;
         enable_auto_fix?: boolean;
+        use_fix_loop?: boolean;
         max_changed_files?: number;
         max_changed_lines?: number;
     };

package/sandbox/dist/core/bot-logins.js

@@ -6,9 +6,22 @@ export const KNOWN_DOISTBOT_LOGINS = new Set([
     'doistbot-app',
     'doistbot-app[bot]',
 ]);
+export const KNOWN_AUTOMATION_LOGINS = new Set([
+    ...KNOWN_DOISTBOT_LOGINS,
+    'dependabot',
+    'dependabot[bot]',
+    'renovate',
+    'renovate[bot]',
+]);
 export function isKnownDoistbotLogin(login) {
     if (!login) {
         return false;
     }
     return KNOWN_DOISTBOT_LOGINS.has(login.toLowerCase());
 }
+export function isKnownAutomationLogin(login) {
+    if (!login) {
+        return false;
+    }
+    return KNOWN_AUTOMATION_LOGINS.has(login.toLowerCase());
+}

package/sandbox/dist/core/retry.js

@@ -0,0 +1,29 @@
+/** Default per-attempt delays for retrying transient HTTP failures. */
+export const HTTP_RETRY_DELAYS_MS = [250, 500, 1000];
+/** True for HTTP errors that are typically worth retrying: 429 and any 5xx. */
+function isTransientHttpError(error) {
+    const status = error?.status;
+    return typeof status === 'number' && (status === 429 || (status >= 500 && status < 600));
+}
+/**
+ * Retries `fn` on errors classified as retryable, sleeping between attempts.
+ * Total attempts = 1 + delaysMs.length. Throws immediately on a non-retryable
+ * error, or after the budget is exhausted (re-throwing the last error).
+ *
+ * Defaults match HTTP usage (429 / 5xx with exponential backoff). Pass
+ * `delaysMs` / `isRetryable` to retry against a different signal.
+ */
+export async function withRetry(fn, delaysMs = HTTP_RETRY_DELAYS_MS, isRetryable = isTransientHttpError) {
+    let attempt = 0;
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (!isRetryable(error) || attempt >= delaysMs.length)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
+            attempt++;
+        }
+    }
+}

package/sandbox/dist/core/shared.js

@@ -44,8 +44,8 @@ export function parseBaseContext() {
     return {
         owner: requiredEnv('REPO_OWNER'),
         repo: requiredEnv('REPO_NAME'),
-        prNumber: Number(requiredEnv('PR_NUMBER')),
-        installationId: Number(requiredEnv('INSTALLATION_ID')),
+        prNumber: requiredPositiveInt('PR_NUMBER'),
+        installationId: requiredPositiveInt('INSTALLATION_ID'),
         appId: requiredEnv('APP_ID'),
         privateKey: requiredEnv('PRIVATE_KEY'),
         githubToken: process.env.GITHUB_TOKEN?.trim() || undefined,

package/sandbox/dist/main.js

@@ -12,6 +12,9 @@ switch (taskType) {
     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();

package/sandbox/dist/tasks/issue-fix-retry/fix-retry.js

@@ -161,13 +161,7 @@ async function main() {
             octokit: writeOctokit,
             triageOutput,
             fixAssessment,
-            clonedRepos: clonedRepositories.map(({ repository, localPath }) => ({
-                owner: repository.owner,
-                repo: repository.repo,
-                fullName: repository.fullName,
-                localPath,
-                repository,
-            })),
+            clonedRepos: clonedRepositories,
             issueTitle: issue.title ?? 'Untitled issue',
             issueUrl: issue.html_url ?? getIssueUrl(ctx.owner, ctx.repo, ctx.issueNumber),
             ghToken: issueInstallationAuth.token,