@regressionproof/cli 0.7.4 → 0.9.0

package/build/doctor/DoctorResult.d.ts

@@ -0,0 +1,8 @@
+type DoctorStatus = 'ok' | 'warn' | 'fail';
+interface DoctorResult {
+    name: string;
+    status: DoctorStatus;
+    details: string[];
+    fix?: string;
+}
+export { DoctorResult, DoctorStatus };

package/build/doctor/DoctorResult.js

@@ -0,0 +1 @@
+export {};

package/build/doctor/DoctorRunner.d.ts

@@ -0,0 +1,9 @@
+import type { DoctorResult } from './DoctorResult.js';
+export default class DoctorRunner {
+    static run(options?: DoctorRunOptions): Promise<DoctorResult[]>;
+}
+export interface DoctorRunOptions {
+    cwd?: string;
+    apiUrl?: string;
+    fix?: boolean;
+}

package/build/doctor/DoctorRunner.js

@@ -0,0 +1,13 @@
+import Doctor from './Doctor.js';
+import DoctorContext from './DoctorContext.js';
+export default class DoctorRunner {
+    static async run(options) {
+        const cwd = options?.cwd ?? process.cwd();
+        const apiUrl = options?.apiUrl ??
+            process.env.REGRESSIONPROOF_API_URL ??
+            'https://api.regressionproof.ai';
+        const fix = options?.fix ?? false;
+        const context = DoctorContext.fromCwd(cwd, apiUrl, fix);
+        return new Doctor(context).run();
+    }
+}

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

@@ -0,0 +1,5 @@
+import DoctorContext from '../DoctorContext.js';
+import type { DoctorResult } from '../DoctorResult.js';
+export default class ApiReachabilityCheck {
+    run(context: DoctorContext): Promise<DoctorResult>;
+}

package/build/doctor/checks/ApiReachabilityCheck.js

@@ -0,0 +1,41 @@
+export default class ApiReachabilityCheck {
+    async run(context) {
+        const checkName = `rp-doctor-${Date.now()}`;
+        const url = `${context.apiUrl}/check-name/${checkName}`;
+        try {
+            const response = await fetch(url, { method: 'GET' });
+            if (response.ok) {
+                return {
+                    status: 'ok',
+                    name: 'API reachability',
+                    details: [`API responded at ${context.apiUrl}.`],
+                };
+            }
+            if (response.status === 502) {
+                return {
+                    status: 'warn',
+                    name: 'API reachability',
+                    details: [
+                        'API is reachable, but Git server communication failed (502).',
+                    ],
+                    fix: 'Check the Git server connectivity or API configuration.',
+                };
+            }
+            return {
+                status: 'warn',
+                name: 'API reachability',
+                details: [`API responded with status ${response.status}.`],
+                fix: 'Verify REGRESSIONPROOF_API_URL or check API logs.',
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                status: 'fail',
+                name: 'API reachability',
+                details: [`API request failed: ${message}`],
+                fix: 'Check your network or verify REGRESSIONPROOF_API_URL.',
+            };
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import DoctorContext from '../DoctorContext.js';
+import type { DoctorResult } from '../DoctorResult.js';
+export default class CredentialsCheck {
+    run(context: DoctorContext): Promise<DoctorResult>;
+    private safeReadJson;
+}

package/build/doctor/checks/CredentialsCheck.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import ConfigManager from '../../config/ConfigManager.js';
+export default class CredentialsCheck {
+    async run(context) {
+        if (!context.projectName) {
+            return {
+                name: 'Credentials for project',
+                status: 'warn',
+                details: [
+                    'Unable to resolve project name from .regressionproof.json.',
+                ],
+                fix: 'Run `npx regressionproof init` from the project root.',
+            };
+        }
+        const configManager = new ConfigManager();
+        const configPath = context.credentialsPath;
+        if (!configPath || !fs.existsSync(configPath)) {
+            return {
+                name: `Credentials for project "${context.projectName}"`,
+                status: 'fail',
+                details: [
+                    `Missing credentials at ${configPath ??
+                        configManager.getConfigDir(context.projectName)}.`,
+                ],
+                fix: 'Run `npx regressionproof invite accept <token>` (teammate) or `npx regressionproof init` (owner).',
+            };
+        }
+        const parsed = this.safeReadJson(configPath);
+        const url = parsed?.remote?.url;
+        const token = parsed?.remote?.token;
+        if (!url || !token) {
+            return {
+                name: `Credentials for project "${context.projectName}"`,
+                status: 'fail',
+                details: [
+                    'Credentials file is missing remote.url or remote.token.',
+                ],
+                fix: 'Run `npx regressionproof invite accept <token>` to refresh credentials.',
+            };
+        }
+        return {
+            name: `Credentials for project "${context.projectName}"`,
+            status: 'ok',
+            details: [`Credentials found at ${configPath}.`],
+        };
+    }
+    safeReadJson(filePath) {
+        try {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import DoctorContext from '../DoctorContext.js';
+import type { DoctorResult } from '../DoctorResult.js';
+export default class JestReporterCheck {
+    run(context: DoctorContext): Promise<DoctorResult>;
+}

package/build/doctor/checks/JestReporterCheck.js

@@ -0,0 +1,35 @@
+import JestReporterConfigInspector from '../../jest/JestReporterConfigInspector.js';
+export default class JestReporterCheck {
+    async run(context) {
+        const inspector = new JestReporterConfigInspector();
+        const inspection = inspector.inspect(context.cwd);
+        if (!inspection.hasPackageJson) {
+            return {
+                name: 'Jest reporter configured',
+                status: 'warn',
+                details: ['No package.json found in the current directory.'],
+                fix: 'Run `npx regressionproof init` from the project root.',
+            };
+        }
+        if (inspection.isInstalled && inspection.isConfigured) {
+            return {
+                name: 'Jest reporter configured',
+                status: 'ok',
+                details: ['Reporter is installed and configured.'],
+            };
+        }
+        const details = [];
+        if (!inspection.isInstalled) {
+            details.push('Reporter package is not installed.');
+        }
+        if (!inspection.isConfigured) {
+            details.push('Jest config does not include the reporter.');
+        }
+        return {
+            name: 'Jest reporter configured',
+            status: 'warn',
+            details,
+            fix: 'Run `npx regressionproof init` or add the reporter to your Jest config.',
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+import DoctorContext from '../DoctorContext.js';
+import type { DoctorResult } from '../DoctorResult.js';
+export default class LocalConfigCheck {
+    run(context: DoctorContext): Promise<DoctorResult>;
+}

package/build/doctor/checks/LocalConfigCheck.js

@@ -0,0 +1,17 @@
+export default class LocalConfigCheck {
+    async run(context) {
+        if (!context.localConfigPath) {
+            return {
+                name: 'Local project config (.regressionproof.json)',
+                status: 'warn',
+                details: [`Missing .regressionproof.json in ${context.cwd}.`],
+                fix: 'Run `npx regressionproof init` from the project root.',
+            };
+        }
+        return {
+            name: 'Local project config (.regressionproof.json)',
+            status: 'ok',
+            details: [`Found at ${context.localConfigPath}.`],
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import DoctorContext from '../DoctorContext.js';
+import type { DoctorResult } from '../DoctorResult.js';
+export default class MirrorAccessCheck {
+    run(context: DoctorContext): Promise<DoctorResult>;
+    private checkPullAccess;
+    private checkPushAccess;
+    private isNoCommitsError;
+    private isNonFastForwardError;
+    private isDivergedBranchError;
+    private trySyncMirror;
+    private getErrorMessage;
+}

package/build/doctor/checks/MirrorAccessCheck.js

@@ -0,0 +1,210 @@
+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) {
+        if (!context.projectName) {
+            return {
+                name: 'Mirror directory',
+                status: 'warn',
+                details: [
+                    'Unable to resolve project name from .regressionproof.json.',
+                ],
+                fix: 'Run `npx regressionproof init` from the project root.',
+            };
+        }
+        const configManager = new ConfigManager();
+        const mirrorPath = context.mirrorPath;
+        const credentials = configManager.loadCredentials(context.projectName);
+        if (!mirrorPath || !fs.existsSync(mirrorPath)) {
+            return {
+                name: 'Mirror directory',
+                status: 'warn',
+                details: [
+                    `Mirror directory not found at ${mirrorPath ??
+                        configManager.getConfigDir(context.projectName)}.`,
+                    'This is normal before the first snapshot is created.',
+                ],
+                fix: 'Run your tests to create the first snapshot.',
+            };
+        }
+        if (!credentials) {
+            return {
+                name: 'Mirror directory',
+                status: 'warn',
+                details: ['Credentials not found; remote access not checked.'],
+                fix: 'Run `npx regressionproof invite accept <token>` (teammate) or `npx regressionproof init` (owner).',
+            };
+        }
+        const authedUrl = credentials.url.replace('://', `://${credentials.token}@`);
+        const pullResult = this.checkPullAccess(authedUrl);
+        if (!pullResult.ok) {
+            return {
+                name: 'Mirror directory',
+                status: 'fail',
+                details: [
+                    'Unable to access remote (pull).',
+                    pullResult.message ?? 'Unknown error.',
+                ],
+                fix: 'Run `npx regressionproof invite accept <token>` to refresh credentials.',
+            };
+        }
+        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',
+                status: 'fail',
+                details: [
+                    'Unable to access remote (push).',
+                    pushResult.message ?? 'Unknown error.',
+                ],
+                fix: 'Run `npx regressionproof invite accept <token>` to refresh credentials.',
+            };
+        }
+        if (pushResult.status === 'warn') {
+            return {
+                name: 'Mirror directory',
+                status: 'warn',
+                details: [
+                    'Remote access confirmed (pull).',
+                    pushResult.message ?? 'Unknown error.',
+                ],
+                fix: 'Run `npx regressionproof doctor --fix` or pull latest changes in the mirror.',
+            };
+        }
+        return {
+            name: 'Mirror directory',
+            status: 'ok',
+            details: [
+                `Mirror directory exists at ${mirrorPath}.`,
+                'Remote access confirmed (pull/push).',
+            ],
+        };
+    }
+    checkPullAccess(url) {
+        try {
+            execSync(`git ls-remote "${url}"`, { stdio: 'pipe' });
+            return { ok: true };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                message: this.getErrorMessage(err),
+            };
+        }
+    }
+    checkPushAccess(mirrorPath, url) {
+        try {
+            execSync(`git -C "${mirrorPath}" push --dry-run "${url}" HEAD`, {
+                stdio: 'pipe',
+            });
+            return { status: 'ok' };
+        }
+        catch (err) {
+            const message = this.getErrorMessage(err);
+            if (this.isNoCommitsError(message)) {
+                return {
+                    status: 'warn',
+                    message: 'No commits in mirror; push check skipped.',
+                    reason: 'no_commits',
+                };
+            }
+            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) {
+        const normalized = message.toLowerCase();
+        return (normalized.includes('src refspec') ||
+            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;
+            return (error.stderr?.toString().trim() ||
+                error.stdout?.toString().trim() ||
+                error.message);
+        }
+        return String(err);
+    }
+}

package/build/esm/cli.js

@@ -1,52 +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 Init from './components/Init.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 {
-    console.log('Usage: regressionproof <command>');
-    console.log('');
-    console.log('Commands:');
-    console.log('  init [projectName]    Initialize a new project');
-    console.log('  invite ...            Manage project invites');
-    process.exit(1);
+    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 {};