@regressionproof/cli 0.3.7 → 0.3.8

package/build/.spruce/settings.json

@@ -0,0 +1,16 @@
+{
+  "scriptUpdater": {
+    "skipped": []
+  },
+  "writer": {
+    "skipped": [
+      "tsconfig.json"
+    ]
+  },
+  "skipped": [
+    "skill"
+  ],
+  "installed": [
+    "test"
+  ]
+}

package/build/cli.d.ts

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

package/build/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';
+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';
+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/commands/invite/AcceptInvite.d.ts

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

package/build/commands/invite/AcceptInvite.js

@@ -0,0 +1,17 @@
+const API_URL = process.env.REGRESSIONPROOF_API_URL ?? 'https://api.regressionproof.ai';
+export default async function acceptInvite(token) {
+    const response = await fetch(`${API_URL}/invites/accept`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ token }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Invite accept failed: ${response.status} ${text}`);
+    }
+    const data = (await response.json());
+    console.log('Project URL:', data.url);
+    console.log('Project token:', data.token);
+}

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

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

package/build/commands/invite/CreateInvite.js

@@ -0,0 +1,42 @@
+import ConfigManager from '../../config/ConfigManager.js';
+import { getRepoNameFromGit, toSlug } from '../../utilities/slug.js';
+const API_URL = process.env.REGRESSIONPROOF_API_URL ?? 'https://api.regressionproof.ai';
+class InviteCreator {
+    configManager;
+    constructor(configManager = new ConfigManager()) {
+        this.configManager = configManager;
+    }
+    async run(projectNameArg, note) {
+        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 = await 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 = await response.text();
+            throw new Error(`Invite create failed: ${response.status} ${text}`);
+        }
+        const data = (await 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 async function createInvite(projectName, note) {
+    const creator = new InviteCreator();
+    await creator.run(projectName, note);
+}

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

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

package/build/commands/invite/ListInvites.js

@@ -0,0 +1,18 @@
+const API_URL = process.env.REGRESSIONPROOF_API_URL ?? 'https://api.regressionproof.ai';
+export default async function listInvites(projectName) {
+    const query = projectName ? `?name=${encodeURIComponent(projectName)}` : '';
+    const response = await fetch(`${API_URL}/invites${query}`);
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Invite list failed: ${response.status} ${text}`);
+    }
+    const data = (await 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/commands/invite/RevokeInvite.d.ts

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

package/build/commands/invite/RevokeInvite.js

@@ -0,0 +1,11 @@
+const API_URL = process.env.REGRESSIONPROOF_API_URL ?? 'https://api.regressionproof.ai';
+export default async function revokeInvite(token) {
+    const response = await fetch(`${API_URL}/invites/${encodeURIComponent(token)}`, {
+        method: 'DELETE',
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Invite revoke failed: ${response.status} ${text}`);
+    }
+    console.log('Invite revoked.');
+}

package/build/components/Init.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export default function Init(props: {
+    projectName?: string;
+}): React.ReactElement;

package/build/components/Init.js

@@ -0,0 +1,286 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { RegressionProofClient } 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';
+import JestConfigurator 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 {
+    checkTimeout = null;
+    apiClient;
+    configManager;
+    constructor(props) {
+        super(props);
+        const providedName = props.projectName;
+        const defaultName = providedName ?? getRepoNameFromGit();
+        this.configManager = new ConfigManager();
+        this.apiClient = new RegressionProofClient(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,
+            };
+        }
+    }
+    componentDidMount() {
+        // 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();
+        }
+    }
+    componentDidUpdate(_, prevState) {
+        if (prevState.name !== this.state.name && this.state.step === 'input') {
+            void this.checkAvailability();
+        }
+    }
+    componentWillUnmount() {
+        this.clearCheckTimeout();
+    }
+    clearCheckTimeout() {
+        if (this.checkTimeout) {
+            clearTimeout(this.checkTimeout);
+            this.checkTimeout = null;
+        }
+    }
+    async checkAvailability() {
+        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);
+    }
+    formatError(err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const cause = err instanceof Error && 'cause' in err ? ` (${err.cause})` : '';
+        return `${message}${cause} - ${API_URL}`;
+    }
+    handleNameChange = (value) => {
+        this.setState({ name: toSlug(value) });
+    };
+    handleSubmit = async () => {
+        const { availability, name } = this.state;
+        if (availability !== 'available' || name.length < 3) {
+            return;
+        }
+        this.setState({ step: 'registering' });
+        await this.register();
+    };
+    async register() {
+        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),
+            });
+        }
+    }
+    async installAndConfigure() {
+        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);
+    }
+    installDependencies() {
+        if (!existsSync('package.json')) {
+            return {
+                success: false,
+                message: 'No package.json found. regressionproof currently supports Node.js + Jest projects.',
+            };
+        }
+        let packageJson;
+        try {
+            packageJson = JSON.parse(readFileSync('package.json', 'utf8'));
+        }
+        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 };
+    }
+    getPackageManager() {
+        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'] };
+    }
+    renderStatusIndicator() {
+        const { availability, errorMessage } = this.state;
+        switch (availability) {
+            case 'idle':
+                return null;
+            case 'checking':
+                return React.createElement(Text, { color: "yellow" }, "checking...");
+            case 'available':
+                return React.createElement(Text, { color: "green" }, "available (press Enter)");
+            case 'taken':
+                return React.createElement(Text, { color: "red" }, "already taken");
+            case 'error':
+                return React.createElement(Text, { color: "red" }, errorMessage);
+        }
+    }
+    renderRegistering() {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { color: "yellow" },
+                "Registering project \"",
+                this.state.name,
+                "\"...")));
+    }
+    renderConfiguring() {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { color: "yellow" }, "Configuring Jest reporter...")));
+    }
+    renderInstalling() {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { color: "yellow" }, "Installing dependencies...")));
+    }
+    renderSuccess() {
+        const { name, credentials, jestConfig } = this.state;
+        const configDir = this.configManager.getConfigDir(name);
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { color: "green", bold: true }, "Project registered successfully!"),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, null,
+                    "Config saved to:",
+                    ' ',
+                    React.createElement(Text, { color: "cyan" },
+                        configDir,
+                        "/config.json")),
+                React.createElement(Text, null,
+                    "Git remote: ",
+                    React.createElement(Text, { color: "cyan" }, credentials?.url)),
+                jestConfig?.configured ? (React.createElement(Text, null,
+                    "Jest reporter added to:",
+                    ' ',
+                    React.createElement(Text, { color: "cyan" }, jestConfig.location))) : (React.createElement(Text, { color: "yellow" }, "Could not auto-configure Jest. Add manually:"))),
+            !jestConfig?.configured && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { color: "gray" }, "// jest.config.js"),
+                React.createElement(Text, { color: "gray" }, "reporters: ['default', '@regressionproof/jest-reporter']"))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "green" }, "Run your tests and snapshots will be captured automatically!"))));
+    }
+    renderError() {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { color: "red", bold: true }, "Registration failed"),
+            React.createElement(Text, { color: "red" }, this.state.errorMessage)));
+    }
+    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" },
+                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" }),
+                    React.createElement(Box, { marginLeft: 2 }, this.renderStatusIndicator())),
+                name.length > 0 && name.length < 3 && (React.createElement(Text, { color: "gray" }, "Name must be at least 3 characters")))));
+    }
+    render() {
+        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) {
+    const { exit } = useApp();
+    return React.createElement(InitComponent, { exit: exit, projectName: props.projectName });
+}