@regressionproof/cli 0.3.7 → 0.3.9

package/build/components/Init.tsx

@@ -0,0 +1,436 @@
+import { spawnSync } from 'node:child_process'
+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'
+import JestConfigurator, { JestConfigResult } from '../jest/JestConfigurator.js'
+import { getRepoNameFromGit, toSlug } from '../utilities/slug.js'
+
+const API_URL =
+    process.env.REGRESSIONPROOF_API_URL ?? 'https://api.regressionproof.ai'
+
+class InitComponent extends React.Component<Props, State> {
+    private checkTimeout: NodeJS.Timeout | null = null
+    private apiClient: RegressionProofClient
+    private configManager: ConfigManager
+
+    public constructor(props: Props) {
+        super(props)
+
+        const providedName = props.projectName
+        const defaultName = providedName ?? getRepoNameFromGit()
+
+        this.configManager = new ConfigManager()
+        this.apiClient = buildRegressionProofClient(API_URL)
+
+        // Check if already registered (idempotent)
+        const existingCreds = this.configManager.loadCredentials(defaultName)
+        if (existingCreds) {
+            this.state = {
+                name: defaultName,
+                step: 'installing',
+                availability: 'available',
+                errorMessage: '',
+                credentials: existingCreds,
+                jestConfig: null,
+            }
+        } else {
+            this.state = {
+                name: defaultName,
+                step: providedName ? 'registering' : 'input',
+                availability: 'idle',
+                errorMessage: '',
+                credentials: null,
+                jestConfig: null,
+            }
+        }
+    }
+
+    public componentDidMount(): void {
+        // If we have a provided name and not already registered, start registration
+        if (this.props.projectName && this.state.step === 'registering') {
+            void this.register()
+        } else if (this.state.step === 'installing') {
+            void this.installAndConfigure()
+        } else {
+            void this.checkAvailability()
+        }
+    }
+
+    public componentDidUpdate(_: Props, prevState: State): void {
+        if (prevState.name !== this.state.name && this.state.step === 'input') {
+            void this.checkAvailability()
+        }
+    }
+
+    public componentWillUnmount(): void {
+        this.clearCheckTimeout()
+    }
+
+    private clearCheckTimeout(): void {
+        if (this.checkTimeout) {
+            clearTimeout(this.checkTimeout)
+            this.checkTimeout = null
+        }
+    }
+
+    private async checkAvailability(): Promise<void> {
+        this.clearCheckTimeout()
+
+        const { name } = this.state
+        if (name.length < 3) {
+            this.setState({ availability: 'idle', errorMessage: '' })
+            return
+        }
+
+        this.setState({ availability: 'checking' })
+
+        this.checkTimeout = setTimeout(async () => {
+            try {
+                const isAvailable =
+                    await this.apiClient.checkNameAvailability(name)
+                this.setState({
+                    availability: isAvailable ? 'available' : 'taken',
+                    errorMessage: '',
+                })
+            } catch (err) {
+                this.setState({
+                    availability: 'error',
+                    errorMessage: this.formatError(err),
+                })
+            }
+        }, 300)
+    }
+
+    private formatError(err: unknown): string {
+        const message = err instanceof Error ? err.message : String(err)
+        const cause =
+            err instanceof Error && 'cause' in err ? ` (${err.cause})` : ''
+        return `${message}${cause} - ${API_URL}`
+    }
+
+    private handleNameChange = (value: string): void => {
+        this.setState({ name: toSlug(value) })
+    }
+
+    private handleSubmit = async (): Promise<void> => {
+        const { availability, name } = this.state
+        if (availability !== 'available' || name.length < 3) {
+            return
+        }
+
+        this.setState({ step: 'registering' })
+        await this.register()
+    }
+
+    private async register(): Promise<void> {
+        const { name } = this.state
+
+        try {
+            const credentials = await this.apiClient.registerProject({ name })
+            this.setState({ credentials })
+
+            this.configManager.saveCredentials(name, credentials)
+            await this.installAndConfigure()
+        } catch (err) {
+            this.setState({
+                step: 'error',
+                errorMessage: err instanceof Error ? err.message : String(err),
+            })
+        }
+    }
+
+    private async installAndConfigure(): Promise<void> {
+        this.setState({ step: 'installing' })
+        const installResult = this.installDependencies()
+        if (!installResult.success) {
+            this.setState({
+                step: 'error',
+                errorMessage:
+                    installResult.message ?? 'Failed to install dependencies.',
+            })
+            return
+        }
+
+        this.setState({ step: 'configuring' })
+        const jestConfigurator = new JestConfigurator()
+        const jestConfig = jestConfigurator.configure()
+        this.setState({ jestConfig, step: 'success' })
+
+        setTimeout(() => this.props.exit(), 3000)
+    }
+
+    private installDependencies(): InstallResult {
+        if (!existsSync('package.json')) {
+            return {
+                success: false,
+                message:
+                    'No package.json found. regressionproof currently supports Node.js + Jest projects.',
+            }
+        }
+
+        let packageJson: {
+            dependencies?: Record<string, string>
+            devDependencies?: Record<string, string>
+        }
+
+        try {
+            packageJson = JSON.parse(readFileSync('package.json', 'utf8')) as {
+                dependencies?: Record<string, string>
+                devDependencies?: Record<string, string>
+            }
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err)
+            return {
+                success: false,
+                message: `Failed to read package.json: ${message}`,
+            }
+        }
+
+        const hasReporter = Boolean(
+            packageJson.dependencies?.['@regressionproof/jest-reporter'] ??
+            packageJson.devDependencies?.['@regressionproof/jest-reporter']
+        )
+        if (hasReporter) {
+            return { success: true }
+        }
+
+        const packageManager = this.getPackageManager()
+        const result = spawnSync(
+            packageManager.command,
+            [...packageManager.args, '@regressionproof/jest-reporter'],
+            {
+                encoding: 'utf8',
+                shell: true,
+            }
+        )
+
+        if (result.error || result.status !== 0) {
+            const details =
+                result.stderr?.trim() ||
+                result.stdout?.trim() ||
+                result.error?.message
+            return {
+                success: false,
+                message: `Failed to install dependencies${
+                    details ? `: ${details}` : ''
+                }`,
+            }
+        }
+
+        return { success: true }
+    }
+
+    private getPackageManager(): PackageManager {
+        if (existsSync('pnpm-lock.yaml')) {
+            return { command: 'pnpm', args: ['add', '-D'] }
+        }
+
+        if (existsSync('yarn.lock')) {
+            return { command: 'yarn', args: ['add', '-D'] }
+        }
+
+        if (existsSync('package-lock.json')) {
+            return { command: 'npm', args: ['install', '-D'] }
+        }
+
+        return { command: 'npm', args: ['install', '-D'] }
+    }
+
+    private renderStatusIndicator(): React.ReactNode {
+        const { availability, errorMessage } = this.state
+
+        switch (availability) {
+            case 'idle':
+                return null
+            case 'checking':
+                return <Text color="yellow">checking...</Text>
+            case 'available':
+                return <Text color="green">available (press Enter)</Text>
+            case 'taken':
+                return <Text color="red">already taken</Text>
+            case 'error':
+                return <Text color="red">{errorMessage}</Text>
+        }
+    }
+
+    private renderRegistering(): React.ReactElement {
+        return (
+            <Box flexDirection="column" padding={1}>
+                <Text color="yellow">
+                    Registering project "{this.state.name}"...
+                </Text>
+            </Box>
+        )
+    }
+
+    private renderConfiguring(): React.ReactElement {
+        return (
+            <Box flexDirection="column" padding={1}>
+                <Text color="yellow">Configuring Jest reporter...</Text>
+            </Box>
+        )
+    }
+
+    private renderInstalling(): React.ReactElement {
+        return (
+            <Box flexDirection="column" padding={1}>
+                <Text color="yellow">Installing dependencies...</Text>
+            </Box>
+        )
+    }
+
+    private renderSuccess(): React.ReactElement {
+        const { name, credentials, jestConfig } = this.state
+        const configDir = this.configManager.getConfigDir(name)
+
+        return (
+            <Box flexDirection="column" padding={1}>
+                <Text color="green" bold>
+                    Project registered successfully!
+                </Text>
+                <Box marginTop={1} flexDirection="column">
+                    <Text>
+                        Config saved to:{' '}
+                        <Text color="cyan">{configDir}/config.json</Text>
+                    </Text>
+                    <Text>
+                        Git remote: <Text color="cyan">{credentials?.url}</Text>
+                    </Text>
+                    {jestConfig?.configured ? (
+                        <Text>
+                            Jest reporter added to:{' '}
+                            <Text color="cyan">{jestConfig.location}</Text>
+                        </Text>
+                    ) : (
+                        <Text color="yellow">
+                            Could not auto-configure Jest. Add manually:
+                        </Text>
+                    )}
+                </Box>
+                {!jestConfig?.configured && (
+                    <Box marginTop={1} flexDirection="column">
+                        <Text color="gray">// jest.config.js</Text>
+                        <Text color="gray">
+                            reporters: ['default',
+                            '@regressionproof/jest-reporter']
+                        </Text>
+                    </Box>
+                )}
+                <Box marginTop={1}>
+                    <Text color="green">
+                        Run your tests and snapshots will be captured
+                        automatically!
+                    </Text>
+                </Box>
+            </Box>
+        )
+    }
+
+    private renderError(): React.ReactElement {
+        return (
+            <Box flexDirection="column" padding={1}>
+                <Text color="red" bold>
+                    Registration failed
+                </Text>
+                <Text color="red">{this.state.errorMessage}</Text>
+            </Box>
+        )
+    }
+
+    private renderInput(): React.ReactElement {
+        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">
+                    <Text bold>Project name:</Text>
+                    <Box>
+                        <TextInput
+                            value={name}
+                            onChange={this.handleNameChange}
+                            onSubmit={this.handleSubmit}
+                            placeholder="my-awesome-project"
+                        />
+                        <Box marginLeft={2}>{this.renderStatusIndicator()}</Box>
+                    </Box>
+                    {name.length > 0 && name.length < 3 && (
+                        <Text color="gray">
+                            Name must be at least 3 characters
+                        </Text>
+                    )}
+                </Box>
+            </Box>
+        )
+    }
+
+    public render(): React.ReactElement {
+        const { step } = this.state
+
+        switch (step) {
+            case 'registering':
+                return this.renderRegistering()
+            case 'installing':
+                return this.renderInstalling()
+            case 'configuring':
+                return this.renderConfiguring()
+            case 'success':
+                return this.renderSuccess()
+            case 'error':
+                return this.renderError()
+            default:
+                return this.renderInput()
+        }
+    }
+}
+
+export default function Init(props: {
+    projectName?: string
+}): React.ReactElement {
+    const { exit } = useApp()
+    return <InitComponent exit={exit} projectName={props.projectName} />
+}
+
+type Step =
+    | 'input'
+    | 'registering'
+    | 'installing'
+    | 'configuring'
+    | 'success'
+    | 'error'
+type Availability = 'idle' | 'checking' | 'available' | 'taken' | 'error'
+
+interface Props {
+    exit: () => void
+    projectName?: string
+}
+
+interface State {
+    name: string
+    step: Step
+    availability: Availability
+    errorMessage: string
+    credentials: Credentials | null
+    jestConfig: JestConfigResult | null
+}
+
+interface PackageManager {
+    command: string
+    args: string[]
+}
+
+interface InstallResult {
+    success: boolean
+    message?: string
+}

package/build/config/ConfigManager.d.ts

@@ -0,0 +1,17 @@
+export default class ConfigManager {
+    private baseDir;
+    constructor(baseDir?: string);
+    getConfigDir(projectName: string): string;
+    saveCredentials(projectName: string, credentials: Credentials): void;
+    loadCredentials(projectName: string): Credentials | null;
+}
+export interface Credentials {
+    url: string;
+    token: string;
+}
+export interface ProjectConfig {
+    remote: {
+        url: string;
+        token: string;
+    };
+}

package/build/config/ConfigManager.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+export default class ConfigManager {
+    baseDir;
+    constructor(baseDir = path.join(os.homedir(), '.regressionproof')) {
+        this.baseDir = baseDir;
+    }
+    getConfigDir(projectName) {
+        return path.join(this.baseDir, projectName);
+    }
+    saveCredentials(projectName, credentials) {
+        const configDir = this.getConfigDir(projectName);
+        fs.mkdirSync(configDir, { recursive: true });
+        const configPath = path.join(configDir, 'config.json');
+        const config = {
+            remote: {
+                url: credentials.url,
+                token: credentials.token,
+            },
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    loadCredentials(projectName) {
+        const configPath = path.join(this.getConfigDir(projectName), 'config.json');
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        return {
+            url: config.remote.url,
+            token: config.remote.token,
+        };
+    }
+}

package/build/esm/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/build/esm/cli.js

@@ -0,0 +1,52 @@
+#!/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';
+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>');
+            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);
+}

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

@@ -0,0 +1 @@
+export default function acceptInvite(token: string): Promise<void>;

package/build/esm/commands/invite/AcceptInvite.js

@@ -0,0 +1,29 @@
+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());
+    });
+};
+var _a;
+const API_URL = (_a = process.env.REGRESSIONPROOF_API_URL) !== null && _a !== void 0 ? _a : 'https://api.regressionproof.ai';
+export default function acceptInvite(token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${API_URL}/invites/accept`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ token }),
+        });
+        if (!response.ok) {
+            const text = yield response.text();
+            throw new Error(`Invite accept failed: ${response.status} ${text}`);
+        }
+        const data = (yield response.json());
+        console.log('Project URL:', data.url);
+        console.log('Project token:', data.token);
+    });
+}

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

@@ -0,0 +1 @@
+export default function createInvite(projectName?: string, note?: string): Promise<void>;

package/build/esm/commands/invite/CreateInvite.js

@@ -0,0 +1,55 @@
+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());
+    });
+};
+var _a;
+import ConfigManager from '../../config/ConfigManager.js.js';
+import { getRepoNameFromGit, toSlug } from '../../utilities/slug.js.js';
+const API_URL = (_a = process.env.REGRESSIONPROOF_API_URL) !== null && _a !== void 0 ? _a : 'https://api.regressionproof.ai';
+class InviteCreator {
+    constructor(configManager = new ConfigManager()) {
+        this.configManager = configManager;
+    }
+    run(projectNameArg, note) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectName = this.resolveProjectName(projectNameArg);
+            const creds = this.configManager.loadCredentials(projectName);
+            if (!creds) {
+                throw new Error(`No credentials found for ${projectName}. Run regressionproof init first.`);
+            }
+            const response = yield fetch(`${API_URL}/invites`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${creds.token}`,
+                },
+                body: JSON.stringify({ name: projectName, note }),
+            });
+            if (!response.ok) {
+                const text = yield response.text();
+                throw new Error(`Invite create failed: ${response.status} ${text}`);
+            }
+            const data = (yield response.json());
+            console.log('Invite token:', data.token);
+        });
+    }
+    resolveProjectName(projectNameArg) {
+        const provided = projectNameArg ? toSlug(projectNameArg) : '';
+        const name = provided || getRepoNameFromGit();
+        if (!name) {
+            throw new Error('Project name is required. Provide it explicitly or ensure git origin is set.');
+        }
+        return name;
+    }
+}
+export default function createInvite(projectName, note) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const creator = new InviteCreator();
+        yield creator.run(projectName, note);
+    });
+}

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

@@ -0,0 +1 @@
+export default function listInvites(projectName?: string): Promise<void>;

package/build/esm/commands/invite/ListInvites.js

@@ -0,0 +1,30 @@
+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());
+    });
+};
+var _a;
+const API_URL = (_a = process.env.REGRESSIONPROOF_API_URL) !== null && _a !== void 0 ? _a : 'https://api.regressionproof.ai';
+export default function listInvites(projectName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const query = projectName ? `?name=${encodeURIComponent(projectName)}` : '';
+        const response = yield fetch(`${API_URL}/invites${query}`);
+        if (!response.ok) {
+            const text = yield response.text();
+            throw new Error(`Invite list failed: ${response.status} ${text}`);
+        }
+        const data = (yield response.json());
+        if (data.length === 0) {
+            console.log('No invites found.');
+            return;
+        }
+        for (const invite of data) {
+            console.log(`${invite.projectName} | ${invite.status} | created ${invite.createdAt}` +
+                (invite.note ? ` | ${invite.note}` : ''));
+        }
+    });
+}

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

@@ -0,0 +1 @@
+export default function revokeInvite(token: string): Promise<void>;