@regressionproof/cli 0.8.0 → 0.9.1

package/build/doctor/checks/MirrorAccessCheck.d.ts

@@ -5,5 +5,8 @@ export default class MirrorAccessCheck {
     private checkPullAccess;
     private checkPushAccess;
     private isNoCommitsError;
+    private isNonFastForwardError;
+    private isDivergedBranchError;
+    private trySyncMirror;
     private getErrorMessage;
 }

package/build/doctor/checks/MirrorAccessCheck.js

@@ -1,5 +1,6 @@
 import { execSync } from 'child_process';
 import fs from 'fs';
+import { MirrorSyncer } from '@regressionproof/snapshotter';
 import ConfigManager from '../../config/ConfigManager.js';
 export default class MirrorAccessCheck {
     async run(context) {
@@ -50,6 +51,54 @@ export default class MirrorAccessCheck {
             };
         }
         const pushResult = this.checkPushAccess(mirrorPath, authedUrl);
+        if (context.fix && pushResult.status === 'warn') {
+            if (pushResult.reason === 'non_fast_forward') {
+                const fixResult = await this.trySyncMirror(mirrorPath);
+                if (!fixResult.ok) {
+                    const message = fixResult.message ?? 'Unknown error.';
+                    if (this.isDivergedBranchError(message)) {
+                        return {
+                            name: 'Mirror directory',
+                            status: 'warn',
+                            details: [
+                                'Mirror has diverged; manual merge/rebase required.',
+                            ],
+                            fix: 'Run `git -C <mirror> pull --rebase` (or merge) to resolve divergence.',
+                        };
+                    }
+                    return {
+                        name: 'Mirror directory',
+                        status: 'fail',
+                        details: ['Unable to sync mirror.', message],
+                        fix: 'Run `npx regressionproof doctor --fix` again or pull the mirror manually.',
+                    };
+                }
+                const retryResult = this.checkPushAccess(mirrorPath, authedUrl);
+                if (retryResult.status === 'ok') {
+                    return {
+                        name: 'Mirror directory',
+                        status: 'ok',
+                        details: [
+                            `Mirror directory exists at ${mirrorPath}.`,
+                            'Mirror synced successfully.',
+                            'Remote access confirmed (pull/push).',
+                        ],
+                    };
+                }
+                return {
+                    name: 'Mirror directory',
+                    status: 'warn',
+                    details: [
+                        `Mirror directory exists at ${mirrorPath}.`,
+                        'Mirror sync completed; recheck push access.',
+                    ],
+                    fix: 'Re-run `npx regressionproof doctor` to confirm sync results.',
+                };
+            }
+            else {
+                throw new Error('Doctor --fix not implemented for this mirror issue.');
+            }
+        }
         if (pushResult.status === 'fail') {
             return {
                 name: 'Mirror directory',
@@ -69,7 +118,7 @@ export default class MirrorAccessCheck {
                     'Remote access confirmed (pull).',
                     pushResult.message ?? 'Unknown error.',
                 ],
-                fix: 'Run your tests to create the first snapshot.',
+                fix: 'Run `npx regressionproof doctor --fix` or pull latest changes in the mirror.',
             };
         }
         return {
@@ -106,9 +155,17 @@ export default class MirrorAccessCheck {
                 return {
                     status: 'warn',
                     message: 'No commits in mirror; push check skipped.',
+                    reason: 'no_commits',
                 };
             }
-            return { status: 'fail', message };
+            if (this.isNonFastForwardError(message)) {
+                return {
+                    status: 'warn',
+                    message: 'Remote has newer commits; mirror is behind (non-fast-forward).',
+                    reason: 'non_fast_forward',
+                };
+            }
+            return { status: 'fail', message, reason: 'other' };
         }
     }
     isNoCommitsError(message) {
@@ -117,6 +174,30 @@ export default class MirrorAccessCheck {
             normalized.includes('does not match any') ||
             normalized.includes('no commits'));
     }
+    isNonFastForwardError(message) {
+        const normalized = message.toLowerCase();
+        return (normalized.includes('fetch first') ||
+            normalized.includes('non-fast-forward') ||
+            normalized.includes('failed to push some refs'));
+    }
+    isDivergedBranchError(message) {
+        const normalized = message.toLowerCase();
+        return (normalized.includes('diverging branches') ||
+            normalized.includes('not possible to fast-forward'));
+    }
+    async trySyncMirror(mirrorPath) {
+        try {
+            const syncer = new MirrorSyncer();
+            await syncer.syncBlocking(mirrorPath);
+            return { ok: true };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                message: this.getErrorMessage(err),
+            };
+        }
+    }
     getErrorMessage(err) {
         if (err && typeof err === 'object') {
             const error = err;

package/build/esm/cli.js

@@ -1,96 +1,28 @@
 #!/usr/bin/env node
 import 'dotenv/config';
-import { render } from 'ink';
-import React from 'react';
-import acceptInvite from './commands/invite/AcceptInvite.js.js';
-import createInvite from './commands/invite/CreateInvite.js.js';
-import listInvites from './commands/invite/ListInvites.js.js';
-import revokeInvite from './commands/invite/RevokeInvite.js.js';
-import Doctor from './components/Doctor.js.js';
-import Init from './components/Init.js.js';
-import DoctorOutput from './doctor/DoctorOutput.js.js';
-import DoctorRunner from './doctor/DoctorRunner.js.js';
+import { runCommand } from './commands/CommandRunner.js.js';
+import { getCommandHandler } from './commands/commands.js.js';
 const command = process.argv[2];
-const projectNameArg = process.argv[3];
-if (command === 'init') {
-    render(React.createElement(Init, { projectName: projectNameArg }));
-}
-else if (command === 'invite') {
-    const subcommand = process.argv[3];
-    const arg = process.argv[4];
-    if (subcommand === 'create') {
-        const noteArg = process.argv.find((value) => value.startsWith('--note='));
-        const note = noteArg ? noteArg.replace('--note=', '') : undefined;
-        void createInvite(arg, note);
-    }
-    else if (subcommand === 'accept') {
-        if (!arg) {
-            console.error('Usage: regressionproof invite accept <token>');
-            process.exit(1);
-        }
-        void acceptInvite(arg);
-    }
-    else if (subcommand === 'list') {
-        void listInvites(arg);
-    }
-    else if (subcommand === 'revoke') {
-        if (!arg) {
-            console.error('Usage: regressionproof invite revoke <token>');
+const commandArgs = process.argv.slice(3);
+const handler = getCommandHandler(command);
+if (!handler) {
+    void runCommand({
+        heading: 'RegressionProof CLI',
+        handler: () => {
+            console.log('Usage: regressionproof <command>');
+            console.log('');
+            console.log('Commands:');
+            console.log('  init [projectName]    Initialize a new project');
+            console.log('  invite ...            Manage project invites');
+            console.log('  doctor                Check project configuration');
             process.exit(1);
-        }
-        void revokeInvite(arg);
-    }
-    else {
-        console.error('Usage: regressionproof invite <create|accept|list|revoke>');
-        process.exit(1);
-    }
-}
-else if (command === 'doctor') {
-    const options = parseDoctorArgs(process.argv.slice(3));
-    void DoctorRunner.run({ cwd: options.cwd })
-        .then((results) => {
-        if (options.json) {
-            console.log(JSON.stringify(results, null, 2));
-        }
-        else {
-            const { waitUntilExit } = render(React.createElement(Doctor, { results }));
-            void waitUntilExit().then(() => {
-                process.exit(DoctorOutput.exitCode(results));
-            });
-            return;
-        }
-        process.exit(DoctorOutput.exitCode(results));
-    })
-        .catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(message);
-        process.exit(1);
+        },
     });
 }
 else {
-    console.log('Usage: regressionproof <command>');
-    console.log('');
-    console.log('Commands:');
-    console.log('  init [projectName]    Initialize a new project');
-    console.log('  invite ...            Manage project invites');
-    console.log('  doctor                Check project configuration');
-    process.exit(1);
-}
-function parseDoctorArgs(args) {
-    const options = { json: false };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--json') {
-            options.json = true;
-            continue;
-        }
-        if (arg === '--cwd') {
-            const value = args[i + 1];
-            if (value) {
-                options.cwd = value;
-                i++;
-            }
-        }
-    }
-    return options;
+    void runCommand({
+        heading: handler.heading,
+        isInk: handler.isInk,
+        handler: () => handler.run(commandArgs),
+    });
 }

package/build/esm/commands/CommandRunner.d.ts

@@ -0,0 +1,7 @@
+export declare function runCommand(options: RunCommandOptions): Promise<void>;
+interface RunCommandOptions {
+    heading?: string;
+    isInk?: boolean;
+    handler: () => Promise<void> | void;
+}
+export {};

package/build/esm/commands/CommandRunner.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { renderBanner } from '../utilities/renderBanner.js.js';
+export function runCommand(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        renderBanner();
+        if (!options.isInk && options.heading) {
+            console.log(options.heading);
+        }
+        try {
+            yield options.handler();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(message);
+            process.exit(1);
+        }
+    });
+}

package/build/esm/commands/commands.d.ts

@@ -0,0 +1,7 @@
+export declare function getCommandHandler(command?: string): CommandHandler | null;
+interface CommandHandler {
+    heading: string;
+    isInk?: boolean;
+    run: (args: string[]) => Promise<void> | void;
+}
+export {};

package/build/esm/commands/commands.js

@@ -0,0 +1,128 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { render } from 'ink';
+import React from 'react';
+import CommandLayout from '../components/CommandLayout.js.js';
+import Doctor from '../components/Doctor.js.js';
+import Init from '../components/Init.js.js';
+import DoctorOutput from '../doctor/DoctorOutput.js.js';
+import DoctorRunner from '../doctor/DoctorRunner.js.js';
+import acceptInvite from './invite/AcceptInvite.js.js';
+import createInvite from './invite/CreateInvite.js.js';
+import listInvites from './invite/ListInvites.js.js';
+import revokeInvite from './invite/RevokeInvite.js.js';
+const commandHandlers = {
+    init: {
+        heading: 'RegressionProof Init',
+        isInk: true,
+        run: (args) => {
+            const projectName = args[0];
+            render(React.createElement(CommandLayout, { heading: 'RegressionProof Init' }, React.createElement(Init, { projectName })));
+        },
+    },
+    invite: {
+        heading: 'RegressionProof Invite',
+        run: (args) => __awaiter(void 0, void 0, void 0, function* () {
+            const subcommand = args[0];
+            const arg = args[1];
+            if (subcommand === 'create') {
+                const noteArg = args.find((value) => value.startsWith('--note='));
+                const note = noteArg
+                    ? noteArg.replace('--note=', '')
+                    : undefined;
+                yield createInvite(arg, note);
+                return;
+            }
+            if (subcommand === 'accept') {
+                if (!arg) {
+                    throw new Error('Usage: regressionproof invite accept <token>');
+                }
+                yield acceptInvite(arg);
+                return;
+            }
+            if (subcommand === 'list') {
+                yield listInvites(arg);
+                return;
+            }
+            if (subcommand === 'revoke') {
+                if (!arg) {
+                    throw new Error('Usage: regressionproof invite revoke <token>');
+                }
+                yield revokeInvite(arg);
+                return;
+            }
+            throw new Error('Usage: regressionproof invite <create|accept|list|revoke>');
+        }),
+    },
+    doctor: {
+        heading: 'RegressionProof Doctor',
+        isInk: true,
+        run: (args) => __awaiter(void 0, void 0, void 0, function* () {
+            const options = parseDoctorArgs(args);
+            if (options.help) {
+                console.log('RegressionProof Doctor');
+                console.log('');
+                console.log('Usage:\n  regressionproof doctor [--fix] [--json] [--cwd <path>]');
+                console.log('');
+                console.log('Options:');
+                console.log('  --fix     Attempt safe fixes (currently only mirror sync)');
+                console.log('  --json    Output machine-readable JSON');
+                console.log('  --cwd     Run checks for a specific directory');
+                console.log('  --help    Show this help');
+                process.exit(0);
+            }
+            const results = yield DoctorRunner.run({
+                cwd: options.cwd,
+                fix: options.fix,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(results, null, 2));
+                process.exit(DoctorOutput.exitCode(results));
+                return;
+            }
+            const { waitUntilExit } = render(React.createElement(CommandLayout, { heading: 'RegressionProof Doctor' }, React.createElement(Doctor, { results })));
+            yield waitUntilExit();
+            process.exit(DoctorOutput.exitCode(results));
+        }),
+    },
+};
+export function getCommandHandler(command) {
+    var _a;
+    if (!command) {
+        return null;
+    }
+    return (_a = commandHandlers[command]) !== null && _a !== void 0 ? _a : null;
+}
+function parseDoctorArgs(args) {
+    const options = { json: false, fix: false, help: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--json') {
+            options.json = true;
+            continue;
+        }
+        if (arg === '--fix') {
+            options.fix = true;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            options.help = true;
+            continue;
+        }
+        if (arg === '--cwd') {
+            const value = args[i + 1];
+            if (value) {
+                options.cwd = value;
+                i++;
+            }
+        }
+    }
+    return options;
+}

package/build/esm/components/Banner.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Banner(): React.ReactElement;

package/build/esm/components/Banner.js

@@ -0,0 +1,13 @@
+import { Box, Text } from 'ink';
+import BigText from 'ink-big-text';
+import React from 'react';
+import { getCliVersion } from '../utilities/version.js.js';
+export default function Banner() {
+    const version = getCliVersion();
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(BigText, { text: "regressionproof.ai", font: "tiny", colors: ['magenta', 'cyan'] }),
+        React.createElement(Text, { color: "gray" }, "Teaching LLMs to write better code."),
+        React.createElement(Text, { color: "gray" },
+            "CLI v",
+            version)));
+}

package/build/esm/components/CommandHeading.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export default function CommandHeading(props: Props): React.ReactElement;
+interface Props {
+    heading: string;
+}
+export {};

package/build/esm/components/CommandHeading.js

@@ -0,0 +1,5 @@
+import { Text } from 'ink';
+import React from 'react';
+export default function CommandHeading(props) {
+    return React.createElement(Text, { bold: true }, props.heading);
+}

package/build/esm/components/CommandLayout.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export default function CommandLayout(props: Props): React.ReactElement;
+interface Props {
+    heading: string;
+    children?: React.ReactNode;
+}
+export {};

package/build/esm/components/CommandLayout.js

@@ -0,0 +1,8 @@
+import { Box } from 'ink';
+import React from 'react';
+import CommandHeading from './CommandHeading.js.js';
+export default function CommandLayout(props) {
+    return (React.createElement(Box, { flexDirection: "column", paddingX: 1, paddingBottom: 1 },
+        React.createElement(CommandHeading, { heading: props.heading }),
+        React.createElement(Box, { marginTop: 1 }, props.children)));
+}

package/build/esm/components/Doctor.js

@@ -1,27 +1,21 @@
 import { Box, Text } from 'ink';
-import BigText from 'ink-big-text';
 import React from 'react';
 class DoctorComponent extends React.Component {
     render() {
         return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { flexDirection: "column", padding: 1 },
-                React.createElement(BigText, { text: "regressionproof.ai", font: "tiny", colors: ['magenta', 'cyan'] }),
-                React.createElement(Text, { color: "gray" }, "Teaching LLMs to write better code.")),
-            React.createElement(Box, { flexDirection: "column", paddingX: 1, paddingBottom: 1 },
-                React.createElement(Text, { bold: true }, "RegressionProof Doctor"),
-                this.props.results.map((result) => (React.createElement(Box, { key: result.name, flexDirection: "column" },
-                    React.createElement(Box, null,
-                        React.createElement(Text, { color: this.colorFor(result.status) }, this.labelFor(result.status)),
-                        React.createElement(Text, null,
-                            " ",
-                            result.name)),
-                    result.details.map((detail) => (React.createElement(Text, { key: detail },
+            React.createElement(Box, { flexDirection: "column", paddingX: 1, paddingBottom: 1 }, this.props.results.map((result) => (React.createElement(Box, { key: result.name, flexDirection: "column" },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: this.colorFor(result.status) }, this.labelFor(result.status)),
+                    React.createElement(Text, null,
                         " ",
-                        detail))),
-                    result.fix ? (React.createElement(Text, null,
-                        " Fix: ",
-                        result.fix)) : null,
-                    React.createElement(Text, null, " ")))))));
+                        result.name)),
+                result.details.map((detail) => (React.createElement(Text, { key: detail },
+                    " ",
+                    detail))),
+                result.fix ? (React.createElement(Text, null,
+                    " Fix: ",
+                    result.fix)) : null,
+                React.createElement(Text, null, " ")))))));
     }
     labelFor(status) {
         switch (status) {

package/build/esm/components/Init.js

@@ -12,7 +12,6 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { buildRegressionProofClient } from '@regressionproof/client';
 import { Box, Text, useApp } from 'ink';
-import BigText from 'ink-big-text';
 import TextInput from 'ink-text-input';
 import React from 'react';
 import ConfigManager from '../config/ConfigManager.js.js';
@@ -268,10 +267,8 @@ class InitComponent extends React.Component {
     }
     renderInput() {
         const { name } = this.state;
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(BigText, { text: "regressionproof.ai", font: "tiny", colors: ['magenta', 'cyan'] }),
-            React.createElement(Text, { color: "gray" }, "Teaching LLMs to write better code."),
-            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { padding: 1, flexDirection: "column" },
                 React.createElement(Text, { bold: true }, "Project name:"),
                 React.createElement(Box, null,
                     React.createElement(TextInput, { value: name, onChange: this.handleNameChange, onSubmit: this.handleSubmit, placeholder: "my-awesome-project" }),

package/build/esm/doctor/Doctor.d.ts

@@ -4,4 +4,5 @@ export default class Doctor {
     private context;
     constructor(context: DoctorContext);
     run(): Promise<DoctorResult[]>;
+    private runFixOnly;
 }

package/build/esm/doctor/Doctor.js

@@ -7,6 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import ApiReachabilityCheck from './checks/ApiReachabilityCheck.js.js';
 import CredentialsCheck from './checks/CredentialsCheck.js.js';
 import JestReporterCheck from './checks/JestReporterCheck.js.js';
 import LocalConfigCheck from './checks/LocalConfigCheck.js.js';
@@ -22,12 +23,45 @@ export default class Doctor {
                 new JestReporterCheck(),
                 new CredentialsCheck(),
                 new MirrorAccessCheck(),
+                new ApiReachabilityCheck(),
             ];
             const results = [];
+            if (this.context.fix) {
+                return this.runFixOnly(checks, results);
+            }
             for (const check of checks) {
                 results.push(yield check.run(this.context));
             }
             return results;
         });
     }
+    runFixOnly(checks, results) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let mirrorResult;
+            for (const check of checks) {
+                if (check instanceof MirrorAccessCheck) {
+                    mirrorResult = yield check.run(this.context);
+                    results.push(mirrorResult);
+                    break;
+                }
+            }
+            if (!mirrorResult) {
+                throw new Error('Doctor --fix not implemented (missing mirror check).');
+            }
+            if (mirrorResult.status === 'fail') {
+                throw new Error('Doctor --fix not implemented for this mirror issue.');
+            }
+            for (const check of checks) {
+                if (check instanceof MirrorAccessCheck) {
+                    continue;
+                }
+                const result = yield check.run(this.context);
+                results.push(result);
+                if (result.status !== 'ok') {
+                    throw new Error(`Doctor --fix not implemented for ${result.name}.`);
+                }
+            }
+            return results;
+        });
+    }
 }

package/build/esm/doctor/DoctorContext.d.ts

@@ -3,8 +3,10 @@ export default class DoctorContext {
     projectName: string | null;
     localConfigPath: string | null;
     homeConfigDir: string;
-    constructor(cwd: string, projectName: string | null, localConfigPath: string | null, homeConfigDir: string);
-    static fromCwd(cwd: string): DoctorContext;
+    apiUrl: string;
+    fix: boolean;
+    constructor(cwd: string, projectName: string | null, localConfigPath: string | null, homeConfigDir: string, apiUrl: string, fix: boolean);
+    static fromCwd(cwd: string, apiUrl: string, fix: boolean): DoctorContext;
     get configDir(): string | null;
     get credentialsPath(): string | null;
     get mirrorPath(): string | null;

package/build/esm/doctor/DoctorContext.js

@@ -2,20 +2,22 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 export default class DoctorContext {
-    constructor(cwd, projectName, localConfigPath, homeConfigDir) {
+    constructor(cwd, projectName, localConfigPath, homeConfigDir, apiUrl, fix) {
         this.cwd = cwd;
         this.projectName = projectName;
         this.localConfigPath = localConfigPath;
         this.homeConfigDir = homeConfigDir;
+        this.apiUrl = apiUrl;
+        this.fix = fix;
     }
-    static fromCwd(cwd) {
+    static fromCwd(cwd, apiUrl, fix) {
         const localConfigPath = path.join(cwd, '.regressionproof.json');
         const localExists = fs.existsSync(localConfigPath);
         const projectName = localExists
             ? DoctorContext.readProjectName(localConfigPath)
             : null;
         const homeConfigDir = path.join(os.homedir(), '.regressionproof');
-        return new DoctorContext(cwd, projectName, localExists ? localConfigPath : null, homeConfigDir);
+        return new DoctorContext(cwd, projectName, localExists ? localConfigPath : null, homeConfigDir, apiUrl, fix);
     }
     get configDir() {
         return this.projectName

package/build/esm/doctor/DoctorRunner.d.ts

@@ -4,4 +4,6 @@ export default class DoctorRunner {
 }
 export interface DoctorRunOptions {
     cwd?: string;
+    apiUrl?: string;
+    fix?: boolean;
 }

package/build/esm/doctor/DoctorRunner.js

@@ -12,9 +12,11 @@ import DoctorContext from './DoctorContext.js.js';
 export default class DoctorRunner {
     static run(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c, _d;
             const cwd = (_a = options === null || options === void 0 ? void 0 : options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
-            const context = DoctorContext.fromCwd(cwd);
+            const apiUrl = (_c = (_b = options === null || options === void 0 ? void 0 : options.apiUrl) !== null && _b !== void 0 ? _b : process.env.REGRESSIONPROOF_API_URL) !== null && _c !== void 0 ? _c : 'https://api.regressionproof.ai';
+            const fix = (_d = options === null || options === void 0 ? void 0 : options.fix) !== null && _d !== void 0 ? _d : false;
+            const context = DoctorContext.fromCwd(cwd, apiUrl, fix);
             return new Doctor(context).run();
         });
     }