@rvoh/psychic 2.0.4 → 2.2.0

package/dist/cjs/src/bin/helpers/OpenApiSpecDiff.js

@@ -0,0 +1,341 @@
+import { DreamCLI } from '@rvoh/dream/system';
+import * as cp from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import colorize from '../../cli/helpers/colorize.js';
+/**
+ * Class-based OpenAPI specification diff tool
+ *
+ * Compares current OpenAPI specs against the head branch using oasdiff
+ *
+ * Example usages:
+ *
+ * Instance-based usage
+ *    const diffTool = new OpenApiSpecDiff()
+ *    diffTool.compare(openapiConfigs)
+ *
+ * Factory method usage
+ *    const diffTool = OpenApiSpecDiff.create()
+ *    diffTool.compare(openapiConfigs)
+ *
+ * Static method usage (backward compatibility)
+ *    OpenApiSpecDiff.compare(openapiConfigs)
+ */
+export class OpenApiSpecDiff {
+    /**
+     * The configuration for the oasdiff command
+     */
+    oasdiffConfig;
+    /**
+     * Compares a list of OpenAPI specifications between the current branch and the head branch.
+     *
+     * Uses `oasdiff` under the hood to detect breaking and non-breaking changes for each file,
+     * helping you review and validate API updates with confidence before merging.
+     *
+     * This tool only runs for configurations where `checkDiffs` is enabled.
+     *
+     * @param openapiConfigs - An array of tuples containing the OpenAPI file name and its configuration.
+     * @example
+     * ```ts
+     * const openapiConfigs: [string, PsychicOpenapiConfig][] = [
+     *   ['openapi', { outputFilepath: 'openapi.json' }],
+     * ]
+     * OpenApiSpecDiff.compare(openapiConfigs)
+     * ```
+     */
+    compare(openapiConfigs) {
+        const results = [];
+        this.oasdiffConfig = this.getOasDiffConfig();
+        const comparing = colorize(`🔍 Comparing current OpenAPI Specs against ${this.oasdiffConfig.headBranch}...`, { color: 'cyanBright' });
+        DreamCLI.logger.logStartProgress(comparing, { logPrefixColor: 'cyanBright' });
+        DreamCLI.logger.logContinueProgress(`\n`, { logPrefixColor: 'cyanBright' });
+        for (const [openapiName, config] of openapiConfigs) {
+            const result = this.compareConfig(openapiName, config);
+            results.push(result);
+        }
+        this.processResults(results);
+    }
+    /**
+     * Checks if oasdiff is installed locally
+     */
+    hasOasDiffInstalled() {
+        try {
+            cp.execSync('oasdiff --version', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Fetch the head branch of a remote using git remote show origin
+     * default to main if not set
+     */
+    getHeadBranch() {
+        let head = '';
+        const output = cp.execSync('git remote show origin', { encoding: 'utf-8' });
+        const lines = output.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('HEAD branch:')) {
+                head = trimmed.replace('HEAD branch:', '').trim() || 'main';
+            }
+        }
+        return head;
+    }
+    /**
+     * Validates that oasdiff is installed and builds the oasdiff config
+     */
+    getOasDiffConfig() {
+        const headBranch = this.getHeadBranch();
+        if (this.hasOasDiffInstalled()) {
+            DreamCLI.logger.logContinueProgress('🎉 oasdiff package found\n');
+            return {
+                command: 'oasdiff',
+                baseArgs: [],
+                headBranch,
+            };
+        }
+        throw new Error(`⚠️ oasdiff not found.
+    
+      Install it via the instructions here:
+        https://github.com/tufin/oasdiff
+      `);
+    }
+    /**
+     * Runs oasdiff command and returns the output
+     */
+    runOasDiffCommand(subcommand, mainPath, currentPath, flags) {
+        if (!this.oasdiffConfig) {
+            throw new Error('OasDiff config not initialized');
+        }
+        const args = [...this.oasdiffConfig.baseArgs, subcommand, mainPath, currentPath];
+        if (flags && flags.length > 0) {
+            args.push(...flags.map(flag => `--${flag}`));
+        }
+        try {
+            const output = cp.execFileSync(this.oasdiffConfig.command, args, {
+                shell: true,
+                encoding: 'utf8',
+                cwd: process.cwd(),
+                stdio: 'pipe',
+            });
+            return output.trim();
+        }
+        catch (error) {
+            const errorOutput = error instanceof Error ? error.message : String(error);
+            return errorOutput;
+        }
+    }
+    /**
+     * Compares two OpenAPI files using oasdiff
+     */
+    compareSpecs(mainFilePath, currentFilePath) {
+        if (!this.oasdiffConfig) {
+            throw new Error('OasDiff config not initialized');
+        }
+        const breakingChanges = this.runOasDiffCommand('breaking', mainFilePath, currentFilePath);
+        const changelogChanges = this.runOasDiffCommand('changelog', mainFilePath, currentFilePath);
+        const breaking = breakingChanges && !breakingChanges.includes('Command failed')
+            ? breakingChanges.split('\n').filter(line => line.trim())
+            : [];
+        const changelog = changelogChanges && !changelogChanges.includes('Command failed')
+            ? changelogChanges.split('\n').filter(line => line.trim())
+            : [];
+        const failedToCompare = breakingChanges.includes('Command failed')
+            ? breakingChanges
+            : changelogChanges.includes('Command failed')
+                ? changelogChanges
+                : '';
+        return {
+            breaking,
+            changelog,
+            error: failedToCompare,
+        };
+    }
+    /**
+     * Creates a temporary file path for the head branch content
+     */
+    createTempFilePath(filePath) {
+        const tempFileName = `temp_main_${path.basename(filePath)}`;
+        return path.join(path.dirname(filePath), tempFileName);
+    }
+    /**
+     * Retrieves head branch content for a file
+     */
+    getHeadBranchContent(filePath) {
+        if (!this.oasdiffConfig) {
+            throw new Error('OasDiff config not initialized');
+        }
+        const branchRef = process.env.CI === '1' ? `origin/${this.oasdiffConfig.headBranch}` : this.oasdiffConfig.headBranch;
+        return cp.execSync(`git show ${branchRef}:${filePath}`, {
+            encoding: 'utf8',
+            cwd: process.cwd(),
+        });
+    }
+    /**
+     * Compares a single OpenAPI file against head branch
+     */
+    compareConfig(openapiName, config) {
+        const result = {
+            file: openapiName,
+            hasChanges: false,
+            breaking: [],
+            changelog: [],
+        };
+        const currentFilePath = config.outputFilepath;
+        if (!fs.existsSync(currentFilePath)) {
+            result.error = `File ${config.outputFilepath} does not exist in current branch`;
+            return result;
+        }
+        const tempMainFilePath = this.createTempFilePath(config.outputFilepath);
+        const mainContent = this.getHeadBranchContent(config.outputFilepath);
+        fs.mkdirSync(path.dirname(tempMainFilePath), { recursive: true });
+        fs.writeFileSync(tempMainFilePath, mainContent);
+        try {
+            const { breaking, changelog, error } = this.compareSpecs(tempMainFilePath, currentFilePath);
+            result.breaking = breaking;
+            result.changelog = changelog;
+            result.hasChanges = breaking.length > 0 || changelog.length > 0;
+            result.error = error ?? '';
+        }
+        catch (error) {
+            result.error = `Could not retrieve ${config.outputFilepath} from ${this.oasdiffConfig?.headBranch} branch: ${String(error)}`;
+        }
+        finally {
+            if (fs.existsSync(tempMainFilePath)) {
+                fs.unlinkSync(tempMainFilePath);
+            }
+        }
+        return result;
+    }
+    /**
+     * Process and display the comparison results
+     */
+    processResults(results) {
+        let hasAnyChanges = false;
+        let hasBreakingChanges = false;
+        for (const result of results) {
+            if (result.error) {
+                this.logError(result);
+            }
+            else if (result.hasChanges) {
+                this.logChanges(result);
+                hasAnyChanges = true;
+                if (result.breaking.length > 0) {
+                    this.logBreakingChanges(result);
+                    hasBreakingChanges = true;
+                }
+                if (result.changelog.length > 0) {
+                    this.logChangelog(result);
+                }
+            }
+            else {
+                this.logNoChanges(result);
+            }
+        }
+        this.logSummary(hasAnyChanges, hasBreakingChanges);
+    }
+    /**
+     * Log error for a comparison result
+     */
+    logError(result) {
+        const file = colorize(`❌ ${result.file}`, { color: 'whiteBright' });
+        const error = colorize(`${result.error}`, { color: 'redBright' });
+        DreamCLI.logger.logContinueProgress(`${file}: ${error}`, { logPrefixColor: 'redBright' });
+    }
+    /**
+     * Log changes for a comparison result
+     */
+    logChanges(result) {
+        const file = colorize(`${result.file}`, { color: 'whiteBright' });
+        const changes = colorize('HAS CHANGES', { color: 'yellowBright' });
+        DreamCLI.logger.logContinueProgress(`${file}: ${changes}`, { logPrefixColor: 'yellowBright' });
+    }
+    /**
+     * Log breaking changes for a comparison result
+     */
+    logBreakingChanges(result) {
+        DreamCLI.logger.logContinueProgress(`   ${colorize(`🚨 BREAKING CHANGES:`, { color: 'redBright' })}`, {
+            logPrefixColor: 'redBright',
+        });
+        result.breaking.forEach(change => {
+            DreamCLI.logger.logContinueProgress(`      ${colorize(`• ${change}`, { color: 'redBright' })}`, {
+                logPrefixColor: 'redBright',
+            });
+        });
+    }
+    /**
+     * Log changelog for a comparison result
+     */
+    logChangelog(result) {
+        DreamCLI.logger.logContinueProgress(`   ${colorize(`📋 CHANGELOG:`, { color: 'blueBright' })}`, {
+            logPrefixColor: 'blueBright',
+        });
+        const changelogLines = result.changelog;
+        changelogLines.forEach(line => {
+            DreamCLI.logger.logContinueProgress(`      ${colorize(line, { color: 'whiteBright' })}`, {
+                logPrefixBgColor: 'bgWhite',
+                logPrefixColor: 'white',
+            });
+        });
+    }
+    /**
+     * Log no changes for a comparison result
+     */
+    logNoChanges(result) {
+        const file = colorize(`${result.file}`, { color: 'whiteBright' });
+        const changes = colorize('No changes', { color: 'greenBright' });
+        DreamCLI.logger.logContinueProgress(`${file}: ${changes}`, { logPrefixColor: 'greenBright' });
+    }
+    /**
+     * Log final summary and handle exit conditions
+     */
+    logSummary(hasAnyChanges, hasBreakingChanges) {
+        DreamCLI.logger.logContinueProgress(`\n${colorize(`${'='.repeat(60)}`, { color: 'gray' })}`, {
+            logPrefixColor: 'gray',
+        });
+        if (hasBreakingChanges) {
+            DreamCLI.logger.logContinueProgress(`${colorize(`🚨 CRITICAL:`, { color: 'redBright' })} ${colorize(`Breaking changes detected in current branch compared to ${this.oasdiffConfig?.headBranch}! Review before merging.`, { color: 'whiteBright' })}`, { logPrefixColor: 'redBright' });
+            DreamCLI.logger.logContinueProgress(`${colorize(`${'='.repeat(60)}`, { color: 'gray' })}`, {
+                logPrefixColor: 'gray',
+            });
+            DreamCLI.logger.logContinueProgress('\n'.repeat(5), {
+                logPrefixColor: 'gray',
+            });
+            throw new BreakingChangesDetectedInOpenApiSpecError(this.oasdiffConfig);
+        }
+        else if (hasAnyChanges) {
+            const summary = colorize(`📊 Summary: Some OpenAPI files have non-breaking changes in current branch compared to ${this.oasdiffConfig?.headBranch}`, { color: 'yellow' });
+            DreamCLI.logger.logContinueProgress(summary, { logPrefixColor: 'yellow' });
+        }
+        else {
+            const summary = colorize(`📊 Summary: All OpenAPI files in current branch are identical to ${this.oasdiffConfig?.headBranch} branch`, { color: 'green' });
+            DreamCLI.logger.logContinueProgress(summary, { logPrefixColor: 'green' });
+        }
+    }
+    /**
+     * Static factory method for convenience
+     */
+    static create() {
+        return new OpenApiSpecDiff();
+    }
+    /**
+     * Static method to maintain compatibility with functional approach
+     */
+    static compare(openapiConfigs) {
+        const instance = OpenApiSpecDiff.create();
+        instance.compare(openapiConfigs);
+    }
+}
+export class BreakingChangesDetectedInOpenApiSpecError extends Error {
+    oasdiffConfig;
+    constructor(oasdiffConfig) {
+        super();
+        this.oasdiffConfig = oasdiffConfig;
+        this.name = 'BreakingChangesDetectedInOpenApiSpecError';
+    }
+    get message() {
+        return `Breaking changes detected in current branch compared to ${this.oasdiffConfig.headBranch}! Review before merging.`;
+    }
+}

package/dist/cjs/src/bin/index.js

@@ -1,7 +1,7 @@
 import { CliFileWriter, DreamBin, DreamCLI } from '@rvoh/dream/system';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import TypesBuilder from '../cli/helpers/TypesBuilder.js';
+import ASTPsychicTypesBuilder from '../cli/helpers/ASTPsychicTypesBuilder.js';
 import generateController from '../generate/controller.js';
 import generateResource from '../generate/resource.js';
 import isObject from '../helpers/isObject.js';
@@ -9,7 +9,9 @@ import OpenapiAppRenderer from '../openapi-renderer/app.js';
 import PsychicApp from '../psychic-app/index.js';
 import enumsFileStr from './helpers/enumsFileStr.js';
 import generateRouteTypes from './helpers/generateRouteTypes.js';
+import { OpenApiSpecDiff } from './helpers/OpenApiSpecDiff.js';
 import printRoutes from './helpers/printRoutes.js';
+export { BreakingChangesDetectedInOpenApiSpecError } from './helpers/OpenApiSpecDiff.js';
 export default class PsychicBin {
     static async generateController(controllerName, actions) {
         await generateController({
@@ -54,11 +56,15 @@ export default class PsychicBin {
             await CliFileWriter.revert();
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static async syncTypes(customTypes = undefined) {
-        DreamCLI.logger.logStartProgress(`syncing types/psychic.ts...`);
-        await TypesBuilder.sync(customTypes);
-        DreamCLI.logger.logEndProgress();
+    static async syncTypes() {
+        await DreamCLI.logger.logProgress(`syncing types/psychic.ts...`, async () => {
+            await new ASTPsychicTypesBuilder().build();
+        });
+    }
+    static openapiDiff() {
+        const psychicApp = PsychicApp.getOrFail();
+        const openapiConfigsWithCheckDiffs = Object.entries(psychicApp.openapi).filter(([, config]) => config.checkDiffs);
+        OpenApiSpecDiff.compare(openapiConfigsWithCheckDiffs);
     }
     static async syncOpenapiTypescriptFiles() {
         DreamCLI.logger.logStartProgress(`syncing openapi types...`);
@@ -117,8 +123,5 @@ export default class PsychicBin {
                 output = { ...output, ...res };
             }
         }
-        if (Object.keys(output).length) {
-            await PsychicBin.syncTypes(output);
-        }
     }
 }

package/dist/cjs/src/cli/helpers/ASTBuilder.js

@@ -0,0 +1,175 @@
+import { DreamApp } from '@rvoh/dream';
+import * as path from 'node:path';
+import ts from 'typescript';
+const f = ts.factory;
+/**
+ * @internal
+ *
+ * This is a base class, which is inherited by the ASTSchemaBuilder,
+ * the ASTKyselyCodegenEnhancer, and the ASTGlobalSchemaBuilder,
+ * each of which is responsible for building up the output of the various
+ * type files consumed by dream internally.
+ *
+ * This base class is just a container for common methods used by all
+ * classes.
+ */
+export default class ASTBuilder {
+    /**
+     * @internal
+     *
+     * builds a new line, useful for injecting new lines into AST statements
+     */
+    newLine() {
+        return f.createIdentifier('\n');
+    }
+    /**
+     * @internal
+     *
+     * given an interface declaration, it will extrace the relevant property statement
+     * by the given property name.
+     */
+    getPropertyFromInterface(interfaceNode, propertyName) {
+        for (const member of interfaceNode.members) {
+            if (ts.isPropertySignature(member)) {
+                if (ts.isIdentifier(member.name) && member.name.text === propertyName) {
+                    return member;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * @internal
+     *
+     * returns an array of string type literals which were extracted from
+     * either a type or type union, depending on what is provided
+     * for the typeAlias. this allows you to safely and easily collect
+     * an array of types given an alias
+     */
+    extractStringLiteralTypeNodesFromTypeOrUnion(typeAlias) {
+        const literals = [];
+        if (ts.isUnionTypeNode(typeAlias.type)) {
+            typeAlias.type.types.forEach(typeNode => {
+                if (ts.isLiteralTypeNode(typeNode) && ts.isStringLiteral(typeNode.literal)) {
+                    literals.push(typeNode);
+                }
+            });
+        }
+        else if (ts.isLiteralTypeNode(typeAlias.type) && ts.isStringLiteral(typeAlias.type.literal)) {
+            literals.push(typeAlias.type);
+        }
+        return literals;
+    }
+    /**
+     * @internal
+     *
+     * returns an array of type literals which were extracted from
+     * either a type or type union, depending on what is provided
+     * for the typeAlias. this allows you to safely and easily collect
+     * an array of types given an alias
+     */
+    extractTypeNodesFromTypeOrUnion(typeAlias) {
+        const literals = [];
+        if (typeAlias.type && ts.isUnionTypeNode(typeAlias.type)) {
+            typeAlias.type.types.forEach(typeNode => {
+                literals.push(typeNode);
+            });
+        }
+        else if (typeAlias.type) {
+            literals.push(typeAlias.type);
+        }
+        return literals;
+    }
+    /**
+     * @internal
+     *
+     * returns the provided node iff
+     *   a.) the node is an exported type alias
+     *   b.) the exported name matches the provided name (or else there was no name provided)
+     *
+     *  otherwise, returns null
+     */
+    exportedTypeAliasOrNull(node, exportName) {
+        if (ts.isTypeAliasDeclaration(node) &&
+            node?.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            (!exportName ? true : node.name.text === exportName))
+            return node;
+        return null;
+    }
+    /**
+     * @internal
+     *
+     * returns the provided node iff
+     *   a.) the node is an exported interface
+     *   b.) the exported name matches the provided name (or else there was no name provided)
+     *
+     *  otherwise, returns null
+     */
+    exportedInterfaceOrNull(node, exportName) {
+        if (ts.isInterfaceDeclaration(node) &&
+            node?.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            (!exportName ? true : node.name.text === exportName))
+            return node;
+        return null;
+    }
+    /**
+     * @internal
+     *
+     * returns the path to the dream.globals.ts file
+     */
+    psychicTypesPath() {
+        const dreamApp = DreamApp.getOrFail();
+        return path.join(dreamApp.projectRoot, dreamApp.paths.types, 'psychic.ts');
+    }
+    /**
+     * @internal
+     *
+     * safely runs prettier against the provided output. If prettier
+     * is not installed, then the original output is returned
+     */
+    async prettier(output) {
+        try {
+            // dynamically, safely bring in prettier.
+            // ini the event that it fails, we will return the
+            // original output, unformatted, since prettier
+            // is technically not a real dependency of dream,
+            // though psychic and dream apps are provisioned
+            // with prettier by default, so this should usually work
+            const prettier = (await import('prettier')).default;
+            const results = await prettier.format(output, {
+                parser: 'typescript',
+                semi: false,
+                singleQuote: true,
+                tabWidth: 2,
+                lineWidth: 80,
+            });
+            return typeof results === 'string' ? results : output;
+        }
+        catch {
+            // intentional noop, we don't want to raise if prettier
+            // fails, since it is possible for the end user to not
+            // want to use prettier, and it is not a required peer
+            // dependency of dream
+            return output;
+        }
+    }
+    /**
+     * @internal
+     *
+     * given a type node, it will send back the first found generic
+     * provided to that type.
+     */
+    getFirstGenericType(node) {
+        if (ts.isTypeReferenceNode(node)) {
+            if (node.typeArguments && node.typeArguments.length > 0) {
+                return node.typeArguments[0];
+            }
+        }
+        else if (ts.isCallExpression(node)) {
+            if (node.typeArguments && node.typeArguments.length > 0) {
+                return node.typeArguments[0];
+            }
+        }
+        return null;
+    }
+}

package/dist/cjs/src/cli/helpers/ASTPsychicTypesBuilder.js

@@ -0,0 +1,59 @@
+import { CliFileWriter, DreamCLI } from '@rvoh/dream/system';
+import ts from 'typescript';
+import PsychicApp from '../../psychic-app/index.js';
+import ASTBuilder from './ASTBuilder.js';
+const f = ts.factory;
+/**
+ * Responsible for building dream globals, which can be found at
+ * types/dream.globals.ts.
+ *
+ * This class leverages internal AST building mechanisms built into
+ * typescript to manually build up object literals and interfaces
+ * for our app to consume.
+ */
+export default class ASTPsychicTypesBuilder extends ASTBuilder {
+    async build() {
+        const logger = DreamCLI.logger;
+        const sourceFile = ts.createSourceFile('', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+        await logger.logProgress('[psychic] building psychic types', async () => {
+            const output = await this.prettier(this.printStatements(this.buildPsychicTypes(), sourceFile));
+            await CliFileWriter.write(this.psychicTypesPath(), output);
+        });
+    }
+    /**
+     * @internal
+     *
+     * builds up the `export const psychicTypes = ...` statement within the types/psychic.ts
+     * file. It does this by leveraging low-level AST utils built into typescript
+     * to manually build up an object literal, cast it as a const, and write it to
+     * an exported variable.
+     */
+    buildPsychicTypes() {
+        const psychicApp = PsychicApp.getOrFail();
+        const psychicTypesObjectLiteral = f.createObjectLiteralExpression([
+            f.createPropertyAssignment(f.createIdentifier('openapiNames'), f.createArrayLiteralExpression(Object.keys(psychicApp.openapi).map(key => f.createStringLiteral(key)))),
+        ], true);
+        // add "as const" to the end of the schema object we
+        // have built before returning it
+        const constAssertion = f.createAsExpression(psychicTypesObjectLiteral, f.createKeywordTypeNode(ts.SyntaxKind.ConstKeyword));
+        const psychicTypesObjectLiteralConst = f.createVariableStatement(undefined, f.createVariableDeclarationList([
+            f.createVariableDeclaration(f.createIdentifier('psychicTypes'), undefined, undefined, constAssertion),
+        ], ts.NodeFlags.Const));
+        const defaultExportIdentifier = f.createIdentifier('psychicTypes');
+        const exportDefaultStatement = f.createExportDefault(defaultExportIdentifier);
+        return [psychicTypesObjectLiteralConst, this.newLine(), exportDefaultStatement];
+    }
+    /**
+     * @internal
+     *
+     * writes the compiled statements to string.
+     *
+     */
+    printStatements(statements, sourceFile) {
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed, omitTrailingSemicolon: true });
+        const result = printer.printList(ts.ListFormat.SourceFileStatements, f.createNodeArray(statements), sourceFile);
+        // TODO: add autogenerate disclaimer
+        return `\
+${result}`;
+    }
+}

package/dist/cjs/src/cli/index.js

@@ -1,5 +1,5 @@
 import { DreamCLI } from '@rvoh/dream/system';
-import PsychicBin from '../bin/index.js';
+import PsychicBin, { BreakingChangesDetectedInOpenApiSpecError } from '../bin/index.js';
 import generateController from '../generate/controller.js';
 import generateSyncEnumsInitializer from '../generate/initializer/syncEnums.js';
 import generateSyncOpenapiTypescriptInitializer from '../generate/initializer/syncOpenapiTypescript.js';
@@ -196,6 +196,27 @@ export default class PsychicCLI {
             await PsychicBin.syncOpenapiJson();
             process.exit();
         });
+        program
+            .command('diff:openapi')
+            .description('compares the current branch open api spec file(s) with the main/master/head branch open api spec file(s)')
+            .option('-f', '--fail-on-breaking', 'fail on spec changes that are breaking')
+            .action(async (options) => {
+            await initializePsychicApp();
+            try {
+                PsychicBin.openapiDiff();
+            }
+            catch (error) {
+                if (error instanceof BreakingChangesDetectedInOpenApiSpecError) {
+                    if (options.failOnBreaking) {
+                        console.error(error.message);
+                        process.exit(1);
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
     }
     /**
      * @internal

package/dist/cjs/src/controller/index.js

@@ -131,7 +131,7 @@ export default class PsychicController {
     /**
      * @internal
      *
-     * Used for displaying routes when running `yarn psy routes`
+     * Used for displaying routes when running `pnpm psy routes`
      * cli command
      */
     static get disaplayName() {

package/dist/cjs/src/devtools/helpers/launchDevServer.js

@@ -6,7 +6,7 @@ import UnexpectedUndefined from '../../error/UnexpectedUndefined.js';
 import PsychicApp from '../../psychic-app/index.js';
 const devServerProcesses = {};
 const debugEnabled = debuglog('psychic').enabled;
-export async function launchDevServer(key, { port = 3000, cmd = 'yarn client', timeout = 5000 } = {}) {
+export async function launchDevServer(key, { port = 3000, cmd = 'pnpm client', timeout = 5000 } = {}) {
     if (devServerProcesses[key])
         return;
     if (debugEnabled)

package/dist/cjs/src/error/psychic-app/init-missing-package-manager.js

@@ -10,7 +10,7 @@ within conf/app.ts, you must have a call to "#set('packageManager', '<YOUR_CHOSE
 
   // conf/app.ts
   export default async (psy: PsychicApp) => {
-    psy.set('packageManager', 'yarn')
+    psy.set('packageManager', 'pnpm')
   }
     `;
     }