@regressionproof/cli 0.7.4 → 0.8.0

package/build/cli.js

@@ -6,7 +6,10 @@ import acceptInvite from './commands/invite/AcceptInvite.js';
 import createInvite from './commands/invite/CreateInvite.js';
 import listInvites from './commands/invite/ListInvites.js';
 import revokeInvite from './commands/invite/RevokeInvite.js';
+import Doctor from './components/Doctor.js';
 import Init from './components/Init.js';
+import DoctorOutput from './doctor/DoctorOutput.js';
+import DoctorRunner from './doctor/DoctorRunner.js';
 const command = process.argv[2];
 const projectNameArg = process.argv[3];
 if (command === 'init') {
@@ -42,11 +45,52 @@ else if (command === 'invite') {
         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;
+}

package/build/components/Doctor.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { DoctorResult } from '../doctor/DoctorResult.js';
+export default function Doctor(props: Props): React.ReactElement;
+interface Props {
+    results: DoctorResult[];
+}
+export {};

package/build/components/Doctor.js

@@ -0,0 +1,49 @@
+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 },
+                        " ",
+                        detail))),
+                    result.fix ? (React.createElement(Text, null,
+                        " Fix: ",
+                        result.fix)) : null,
+                    React.createElement(Text, null, " ")))))));
+    }
+    labelFor(status) {
+        switch (status) {
+            case 'ok':
+                return 'OK';
+            case 'warn':
+                return 'WARN';
+            case 'fail':
+                return 'FAIL';
+        }
+    }
+    colorFor(status) {
+        switch (status) {
+            case 'ok':
+                return 'green';
+            case 'warn':
+                return 'yellow';
+            case 'fail':
+                return 'red';
+        }
+    }
+}
+export default function Doctor(props) {
+    return React.createElement(DoctorComponent, { results: props.results });
+}

package/build/components/Doctor.tsx

@@ -0,0 +1,75 @@
+import { Box, Text } from 'ink'
+import BigText from 'ink-big-text'
+import React from 'react'
+import type { DoctorResult } from '../doctor/DoctorResult.js'
+
+class DoctorComponent extends React.Component<Props> {
+    public render(): React.ReactElement {
+        return (
+            <Box flexDirection="column">
+                <Box flexDirection="column" padding={1}>
+                    <BigText
+                        text="regressionproof.ai"
+                        font="tiny"
+                        colors={['magenta', 'cyan']}
+                    />
+                    <Text color="gray">
+                        Teaching LLMs to write better code.
+                    </Text>
+                </Box>
+                <Box flexDirection="column" paddingX={1} paddingBottom={1}>
+                    <Text bold>RegressionProof Doctor</Text>
+                    {this.props.results.map((result) => (
+                        <Box key={result.name} flexDirection="column">
+                            <Box>
+                                <Text color={this.colorFor(result.status)}>
+                                    {this.labelFor(result.status)}
+                                </Text>
+                                <Text> {result.name}</Text>
+                            </Box>
+                            {result.details.map((detail) => (
+                                <Text key={detail}> {detail}</Text>
+                            ))}
+                            {result.fix ? (
+                                <Text> Fix: {result.fix}</Text>
+                            ) : null}
+                            <Text> </Text>
+                        </Box>
+                    ))}
+                </Box>
+            </Box>
+        )
+    }
+
+    private labelFor(status: DoctorResult['status']): string {
+        switch (status) {
+            case 'ok':
+                return 'OK'
+            case 'warn':
+                return 'WARN'
+            case 'fail':
+                return 'FAIL'
+        }
+    }
+
+    private colorFor(
+        status: DoctorResult['status']
+    ): 'green' | 'yellow' | 'red' {
+        switch (status) {
+            case 'ok':
+                return 'green'
+            case 'warn':
+                return 'yellow'
+            case 'fail':
+                return 'red'
+        }
+    }
+}
+
+export default function Doctor(props: Props): React.ReactElement {
+    return <DoctorComponent results={props.results} />
+}
+
+interface Props {
+    results: DoctorResult[]
+}

package/build/doctor/Doctor.d.ts

@@ -0,0 +1,7 @@
+import DoctorContext from './DoctorContext.js';
+import type { DoctorResult } from './DoctorResult.js';
+export default class Doctor {
+    private context;
+    constructor(context: DoctorContext);
+    run(): Promise<DoctorResult[]>;
+}

package/build/doctor/Doctor.js

@@ -0,0 +1,23 @@
+import CredentialsCheck from './checks/CredentialsCheck.js';
+import JestReporterCheck from './checks/JestReporterCheck.js';
+import LocalConfigCheck from './checks/LocalConfigCheck.js';
+import MirrorAccessCheck from './checks/MirrorAccessCheck.js';
+export default class Doctor {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    async run() {
+        const checks = [
+            new LocalConfigCheck(),
+            new JestReporterCheck(),
+            new CredentialsCheck(),
+            new MirrorAccessCheck(),
+        ];
+        const results = [];
+        for (const check of checks) {
+            results.push(await check.run(this.context));
+        }
+        return results;
+    }
+}

package/build/doctor/DoctorContext.d.ts

@@ -0,0 +1,12 @@
+export default class DoctorContext {
+    cwd: string;
+    projectName: string | null;
+    localConfigPath: string | null;
+    homeConfigDir: string;
+    constructor(cwd: string, projectName: string | null, localConfigPath: string | null, homeConfigDir: string);
+    static fromCwd(cwd: string): DoctorContext;
+    get configDir(): string | null;
+    get credentialsPath(): string | null;
+    get mirrorPath(): string | null;
+    private static readProjectName;
+}

package/build/doctor/DoctorContext.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+export default class DoctorContext {
+    cwd;
+    projectName;
+    localConfigPath;
+    homeConfigDir;
+    constructor(cwd, projectName, localConfigPath, homeConfigDir) {
+        this.cwd = cwd;
+        this.projectName = projectName;
+        this.localConfigPath = localConfigPath;
+        this.homeConfigDir = homeConfigDir;
+    }
+    static fromCwd(cwd) {
+        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);
+    }
+    get configDir() {
+        return this.projectName
+            ? path.join(this.homeConfigDir, this.projectName)
+            : null;
+    }
+    get credentialsPath() {
+        return this.configDir ? path.join(this.configDir, 'config.json') : null;
+    }
+    get mirrorPath() {
+        return this.configDir ? path.join(this.configDir, 'mirror') : null;
+    }
+    static readProjectName(localConfigPath) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(localConfigPath, 'utf-8'));
+            return raw.projectName ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/build/doctor/DoctorOutput.d.ts

@@ -0,0 +1,6 @@
+import type { DoctorResult } from './DoctorResult.js';
+export default class DoctorOutput {
+    static print(results: DoctorResult[]): void;
+    static exitCode(results: DoctorResult[]): number;
+    private static formatStatus;
+}

package/build/doctor/DoctorOutput.js

@@ -0,0 +1,32 @@
+export default class DoctorOutput {
+    static print(results) {
+        console.log('===================================');
+        console.log('     RegressionProof Doctor');
+        console.log('===================================');
+        console.log('');
+        for (const result of results) {
+            const label = DoctorOutput.formatStatus(result.status);
+            console.log(`${label} ${result.name}`);
+            for (const detail of result.details) {
+                console.log(`     ${detail}`);
+            }
+            if (result.fix) {
+                console.log(`     Fix: ${result.fix}`);
+            }
+            console.log('');
+        }
+    }
+    static exitCode(results) {
+        return results.some((result) => result.status === 'fail') ? 1 : 0;
+    }
+    static formatStatus(status) {
+        switch (status) {
+            case 'ok':
+                return 'OK  ';
+            case 'warn':
+                return 'WARN';
+            case 'fail':
+                return 'FAIL';
+        }
+    }
+}

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,7 @@
+import type { DoctorResult } from './DoctorResult.js';
+export default class DoctorRunner {
+    static run(options?: DoctorRunOptions): Promise<DoctorResult[]>;
+}
+export interface DoctorRunOptions {
+    cwd?: string;
+}

package/build/doctor/DoctorRunner.js

@@ -0,0 +1,9 @@
+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 context = DoctorContext.fromCwd(cwd);
+        return new Doctor(context).run();
+    }
+}

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,9 @@
+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 getErrorMessage;
+}

package/build/doctor/checks/MirrorAccessCheck.js

@@ -0,0 +1,129 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+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 (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 your tests to create the first snapshot.',
+            };
+        }
+        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.',
+                };
+            }
+            return { status: 'fail', message };
+        }
+    }
+    isNoCommitsError(message) {
+        const normalized = message.toLowerCase();
+        return (normalized.includes('src refspec') ||
+            normalized.includes('does not match any') ||
+            normalized.includes('no commits'));
+    }
+    getErrorMessage(err) {
+        if (err && typeof err === 'object') {
+            const error = err;
+            return (error.stderr?.toString().trim() ||
+                error.stdout?.toString().trim() ||
+                error.message);
+        }
+        return String(err);
+    }
+}