@regressionproof/cli 0.7.4 → 0.9.0

package/build/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';
-import createInvite from './commands/invite/CreateInvite.js';
-import listInvites from './commands/invite/ListInvites.js';
-import revokeInvite from './commands/invite/RevokeInvite.js';
-import Init from './components/Init.js';
+import { runCommand } from './commands/CommandRunner.js';
+import { getCommandHandler } from './commands/commands.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/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/commands/CommandRunner.js

@@ -0,0 +1,15 @@
+import { renderBanner } from '../utilities/renderBanner.js';
+export async function runCommand(options) {
+    renderBanner();
+    if (!options.isInk && options.heading) {
+        console.log(options.heading);
+    }
+    try {
+        await options.handler();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(message);
+        process.exit(1);
+    }
+}

package/build/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/commands/commands.js

@@ -0,0 +1,118 @@
+import { render } from 'ink';
+import React from 'react';
+import CommandLayout from '../components/CommandLayout.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';
+import acceptInvite from './invite/AcceptInvite.js';
+import createInvite from './invite/CreateInvite.js';
+import listInvites from './invite/ListInvites.js';
+import revokeInvite from './invite/RevokeInvite.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: async (args) => {
+            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;
+                await createInvite(arg, note);
+                return;
+            }
+            if (subcommand === 'accept') {
+                if (!arg) {
+                    throw new Error('Usage: regressionproof invite accept <token>');
+                }
+                await acceptInvite(arg);
+                return;
+            }
+            if (subcommand === 'list') {
+                await listInvites(arg);
+                return;
+            }
+            if (subcommand === 'revoke') {
+                if (!arg) {
+                    throw new Error('Usage: regressionproof invite revoke <token>');
+                }
+                await revokeInvite(arg);
+                return;
+            }
+            throw new Error('Usage: regressionproof invite <create|accept|list|revoke>');
+        },
+    },
+    doctor: {
+        heading: 'RegressionProof Doctor',
+        isInk: true,
+        run: async (args) => {
+            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 = await 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 })));
+            await waitUntilExit();
+            process.exit(DoctorOutput.exitCode(results));
+        },
+    },
+};
+export function getCommandHandler(command) {
+    if (!command) {
+        return null;
+    }
+    return commandHandlers[command] ?? 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/components/Banner.d.ts

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

package/build/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';
+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/components/Banner.tsx

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

package/build/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/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/components/CommandHeading.tsx

@@ -0,0 +1,10 @@
+import { Text } from 'ink'
+import React from 'react'
+
+export default function CommandHeading(props: Props): React.ReactElement {
+    return <Text bold>{props.heading}</Text>
+}
+
+interface Props {
+    heading: string
+}

package/build/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/components/CommandLayout.js

@@ -0,0 +1,8 @@
+import { Box } from 'ink';
+import React from 'react';
+import CommandHeading from './CommandHeading.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/components/CommandLayout.tsx

@@ -0,0 +1,17 @@
+import { Box } from 'ink'
+import React from 'react'
+import CommandHeading from './CommandHeading.js'
+
+export default function CommandLayout(props: Props): React.ReactElement {
+    return (
+        <Box flexDirection="column" paddingX={1} paddingBottom={1}>
+            <CommandHeading heading={props.heading} />
+            <Box marginTop={1}>{props.children}</Box>
+        </Box>
+    )
+}
+
+interface Props {
+    heading: string
+    children?: React.ReactNode
+}

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,43 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+class DoctorComponent extends React.Component {
+    render() {
+        return (React.createElement(Box, { flexDirection: "column" },
+            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,
+                        " ",
+                        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,63 @@
+import { Box, Text } from 'ink'
+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" paddingX={1} paddingBottom={1}>
+                    {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/components/Init.js

@@ -2,7 +2,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';
@@ -253,10 +252,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/components/Init.tsx

@@ -3,7 +3,6 @@ import { existsSync, readFileSync } from 'node:fs'
 import type { RegressionProofClient } from '@regressionproof/client'
 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, { Credentials } from '../config/ConfigManager.js'
@@ -347,15 +346,8 @@ class InitComponent extends React.Component<Props, State> {
         const { name } = this.state
 
         return (
-            <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 marginTop={1} flexDirection="column">
+            <Box flexDirection="column">
+                <Box padding={1} flexDirection="column">
                     <Text bold>Project name:</Text>
                     <Box>
                         <TextInput

package/build/doctor/Doctor.d.ts

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

package/build/doctor/Doctor.js

@@ -0,0 +1,55 @@
+import ApiReachabilityCheck from './checks/ApiReachabilityCheck.js';
+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(),
+            new ApiReachabilityCheck(),
+        ];
+        const results = [];
+        if (this.context.fix) {
+            return this.runFixOnly(checks, results);
+        }
+        for (const check of checks) {
+            results.push(await check.run(this.context));
+        }
+        return results;
+    }
+    async runFixOnly(checks, results) {
+        let mirrorResult;
+        for (const check of checks) {
+            if (check instanceof MirrorAccessCheck) {
+                mirrorResult = await 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 = await 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/doctor/DoctorContext.d.ts

@@ -0,0 +1,14 @@
+export default class DoctorContext {
+    cwd: string;
+    projectName: string | null;
+    localConfigPath: string | null;
+    homeConfigDir: string;
+    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;
+    private static readProjectName;
+}

package/build/doctor/DoctorContext.js

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+export default class DoctorContext {
+    cwd;
+    projectName;
+    localConfigPath;
+    homeConfigDir;
+    apiUrl;
+    fix;
+    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, 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, apiUrl, fix);
+    }
+    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';
+        }
+    }
+}