@memberjunction/cli 2.117.0 → 2.119.0

package/dist/commands/test/compare.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class TestCompare extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        runId1: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        runId2: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        commit: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'diff-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/test/compare.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const testing_cli_1 = require("@memberjunction/testing-cli");
+class TestCompare extends core_1.Command {
+    static description = 'Compare test runs for regression detection';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <run-id-1> <run-id-2>',
+        '<%= config.bin %> <%= command.id %> --baseline=<run-id> --current=<run-id>',
+        '<%= config.bin %> <%= command.id %> --suite=<suite-id> --since="2024-01-01"',
+        '<%= config.bin %> <%= command.id %> <run-id-1> <run-id-2> --format=json',
+    ];
+    static args = {
+        runId1: core_1.Args.string({
+            description: 'First test run ID to compare',
+            required: false,
+        }),
+        runId2: core_1.Args.string({
+            description: 'Second test run ID to compare',
+            required: false,
+        }),
+    };
+    static flags = {
+        version: core_1.Flags.string({
+            char: 'v',
+            description: 'Compare runs by version',
+            multiple: true,
+        }),
+        commit: core_1.Flags.string({
+            char: 'c',
+            description: 'Compare runs by git commit',
+            multiple: true,
+        }),
+        'diff-only': core_1.Flags.boolean({
+            description: 'Show only differences',
+            default: false,
+        }),
+        format: core_1.Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['console', 'json', 'markdown'],
+            default: 'console',
+        }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Output file path',
+        }),
+        verbose: core_1.Flags.boolean({
+            description: 'Show detailed information',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TestCompare);
+        try {
+            // Create CompareCommand instance and execute
+            // Context user will be fetched internally after MJ provider initialization
+            const compareCommand = new testing_cli_1.CompareCommand();
+            await compareCommand.execute(args.runId1, args.runId2, {
+                version: flags.version,
+                commit: flags.commit,
+                diffOnly: flags['diff-only'],
+                format: flags.format,
+                output: flags.output,
+                verbose: flags.verbose,
+            });
+        }
+        catch (error) {
+            this.error(error);
+        }
+    }
+}
+exports.default = TestCompare;

package/dist/commands/test/history.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class TestHistory extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        test: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        recent: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        from: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/test/history.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const testing_cli_1 = require("@memberjunction/testing-cli");
+class TestHistory extends core_1.Command {
+    static description = 'View test execution history';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --test=<test-id>',
+        '<%= config.bin %> <%= command.id %> --suite=<suite-id>',
+        '<%= config.bin %> <%= command.id %> --since="2024-01-01"',
+        '<%= config.bin %> <%= command.id %> --limit=50',
+    ];
+    static flags = {
+        test: core_1.Flags.string({
+            char: 't',
+            description: 'Filter by test ID',
+        }),
+        recent: core_1.Flags.integer({
+            char: 'r',
+            description: 'Number of recent runs to show',
+        }),
+        from: core_1.Flags.string({
+            description: 'Show history from date (YYYY-MM-DD)',
+        }),
+        status: core_1.Flags.string({
+            char: 's',
+            description: 'Filter by status',
+        }),
+        format: core_1.Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['console', 'json', 'markdown'],
+            default: 'console',
+        }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Output file path',
+        }),
+        verbose: core_1.Flags.boolean({
+            char: 'v',
+            description: 'Show detailed information',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TestHistory);
+        try {
+            // Create HistoryCommand instance and execute
+            // Context user will be fetched internally after MJ provider initialization
+            const historyCommand = new testing_cli_1.HistoryCommand();
+            await historyCommand.execute(flags.test, {
+                recent: flags.recent,
+                from: flags.from,
+                status: flags.status,
+                format: flags.format,
+                output: flags.output,
+                verbose: flags.verbose,
+            });
+        }
+        catch (error) {
+            this.error(error);
+        }
+    }
+}
+exports.default = TestHistory;

package/dist/commands/test/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Test extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/test/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+class Test extends core_1.Command {
+    static description = 'MemberJunction Testing Framework - Execute and manage tests';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> run <test-id>',
+        '<%= config.bin %> <%= command.id %> run --name="Active Members Count"',
+        '<%= config.bin %> <%= command.id %> suite <suite-id>',
+        '<%= config.bin %> <%= command.id %> list',
+        '<%= config.bin %> <%= command.id %> list --suites',
+        '<%= config.bin %> <%= command.id %> validate --all',
+    ];
+    async run() {
+        this.log('MemberJunction Testing Framework\n');
+        this.log('Available commands:');
+        this.log('  mj test run <test-id>           - Execute a single test');
+        this.log('  mj test suite <suite-id>        - Execute a test suite');
+        this.log('  mj test list                    - List available tests');
+        this.log('  mj test validate                - Validate test definitions');
+        this.log('  mj test history                 - View test execution history');
+        this.log('  mj test compare                 - Compare test runs for regressions');
+        this.log('');
+        this.log('Legacy commands (file-based evals):');
+        this.log('  mj test eval <eval-id>          - Run file-based AI evaluation');
+        this.log('  mj test report --type=eval      - Generate eval report');
+        this.log('');
+        this.log('Run "mj test COMMAND --help" for more information on a command.');
+    }
+}
+exports.default = Test;

package/dist/commands/test/list.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class TestList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        suites: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        types: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        tag: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/test/list.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const testing_cli_1 = require("@memberjunction/testing-cli");
+class TestList extends core_1.Command {
+    static description = 'List available tests, suites, and types';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --suites',
+        '<%= config.bin %> <%= command.id %> --types',
+        '<%= config.bin %> <%= command.id %> --type=agent-eval',
+        '<%= config.bin %> <%= command.id %> --tag=smoke',
+        '<%= config.bin %> <%= command.id %> --status=active --verbose',
+    ];
+    static flags = {
+        suites: core_1.Flags.boolean({
+            description: 'List test suites instead of tests',
+            default: false,
+        }),
+        types: core_1.Flags.boolean({
+            description: 'List test types',
+            default: false,
+        }),
+        type: core_1.Flags.string({
+            char: 't',
+            description: 'Filter by test type',
+        }),
+        tag: core_1.Flags.string({
+            description: 'Filter by tag',
+        }),
+        status: core_1.Flags.string({
+            char: 's',
+            description: 'Filter by status',
+        }),
+        format: core_1.Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['console', 'json', 'markdown'],
+            default: 'console',
+        }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Output file path',
+        }),
+        verbose: core_1.Flags.boolean({
+            char: 'v',
+            description: 'Show detailed information',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TestList);
+        try {
+            // Create ListCommand instance and execute
+            // Context user will be fetched internally after MJ provider initialization
+            const listCommand = new testing_cli_1.ListCommand();
+            await listCommand.execute({
+                suites: flags.suites,
+                types: flags.types,
+                type: flags.type,
+                tag: flags.tag,
+                status: flags.status,
+                format: flags.format,
+                output: flags.output,
+                verbose: flags.verbose,
+            });
+        }
+        catch (error) {
+            this.error(error);
+        }
+    }
+}
+exports.default = TestList;

package/dist/commands/test/run.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class TestRun extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        testId: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/test/run.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const testing_cli_1 = require("@memberjunction/testing-cli");
+class TestRun extends core_1.Command {
+    static description = 'Execute a single test by ID or name';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <test-id>',
+        '<%= config.bin %> <%= command.id %> --name="Active Members Count"',
+        '<%= config.bin %> <%= command.id %> <test-id> --environment=staging',
+        '<%= config.bin %> <%= command.id %> <test-id> --format=json --output=results.json',
+        '<%= config.bin %> <%= command.id %> <test-id> --dry-run',
+    ];
+    static args = {
+        testId: core_1.Args.string({
+            description: 'Test ID to execute',
+            required: false,
+        }),
+    };
+    static flags = {
+        name: core_1.Flags.string({
+            char: 'n',
+            description: 'Test name to execute',
+        }),
+        environment: core_1.Flags.string({
+            char: 'e',
+            description: 'Environment context (dev, staging, prod)',
+        }),
+        format: core_1.Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['console', 'json', 'markdown'],
+            default: 'console',
+        }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Output file path',
+        }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Validate without executing',
+            default: false,
+        }),
+        verbose: core_1.Flags.boolean({
+            char: 'v',
+            description: 'Show detailed execution information',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TestRun);
+        try {
+            // Create RunCommand instance and execute
+            // Context user will be fetched internally after MJ provider initialization
+            const runCommand = new testing_cli_1.RunCommand();
+            await runCommand.execute(args.testId, {
+                name: flags.name,
+                environment: flags.environment,
+                format: flags.format,
+                output: flags.output,
+                dryRun: flags['dry-run'],
+                verbose: flags.verbose,
+            });
+        }
+        catch (error) {
+            this.error(error);
+        }
+    }
+}
+exports.default = TestRun;

package/dist/commands/test/suite.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class TestSuite extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        suiteId: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/test/suite.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const testing_cli_1 = require("@memberjunction/testing-cli");
+class TestSuite extends core_1.Command {
+    static description = 'Execute a test suite';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <suite-id>',
+        '<%= config.bin %> <%= command.id %> --name="Agent Quality Suite"',
+        '<%= config.bin %> <%= command.id %> <suite-id> --format=json',
+        '<%= config.bin %> <%= command.id %> <suite-id> --output=suite-results.json',
+    ];
+    static args = {
+        suiteId: core_1.Args.string({
+            description: 'Test suite ID to execute',
+            required: false,
+        }),
+    };
+    static flags = {
+        name: core_1.Flags.string({
+            char: 'n',
+            description: 'Test suite name to execute',
+        }),
+        format: core_1.Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['console', 'json', 'markdown'],
+            default: 'console',
+        }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Output file path',
+        }),
+        verbose: core_1.Flags.boolean({
+            char: 'v',
+            description: 'Show detailed execution information',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TestSuite);
+        try {
+            // Create SuiteCommand instance and execute
+            // Context user will be fetched internally after MJ provider initialization
+            const suiteCommand = new testing_cli_1.SuiteCommand();
+            await suiteCommand.execute(args.suiteId, {
+                name: flags.name,
+                format: flags.format,
+                output: flags.output,
+                verbose: flags.verbose,
+            });
+        }
+        catch (error) {
+            this.error(error);
+        }
+    }
+}
+exports.default = TestSuite;

package/dist/commands/test/validate.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class TestValidate extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        testId: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'save-report': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/test/validate.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const testing_cli_1 = require("@memberjunction/testing-cli");
+class TestValidate extends core_1.Command {
+    static description = 'Validate test definitions without executing';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <test-id>',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --type=agent-eval',
+        '<%= config.bin %> <%= command.id %> --all --save-report',
+        '<%= config.bin %> <%= command.id %> --all --output=validation-report.md',
+    ];
+    static args = {
+        testId: core_1.Args.string({
+            description: 'Test ID to validate',
+            required: false,
+        }),
+    };
+    static flags = {
+        all: core_1.Flags.boolean({
+            char: 'a',
+            description: 'Validate all tests',
+            default: false,
+        }),
+        type: core_1.Flags.string({
+            char: 't',
+            description: 'Validate tests by type',
+        }),
+        'save-report': core_1.Flags.boolean({
+            description: 'Save validation report to file',
+            default: false,
+        }),
+        format: core_1.Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['console', 'json', 'markdown'],
+            default: 'console',
+        }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Output file path',
+        }),
+        verbose: core_1.Flags.boolean({
+            char: 'v',
+            description: 'Show detailed information',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TestValidate);
+        try {
+            // Create ValidateCommand instance and execute
+            // Context user will be fetched internally after MJ provider initialization
+            const validateCommand = new testing_cli_1.ValidateCommand();
+            await validateCommand.execute(args.testId, {
+                all: flags.all,
+                type: flags.type,
+                saveReport: flags['save-report'],
+                format: flags.format,
+                output: flags.output,
+                verbose: flags.verbose,
+            });
+        }
+        catch (error) {
+            this.error(error);
+        }
+    }
+}
+exports.default = TestValidate;

package/dist/config.d.ts

@@ -47,18 +47,22 @@ export declare const config: {
     coreSchema: string;
     mjRepoUrl: string;
 } | undefined;
-export declare const updatedConfig: () => {
-    cleanDisabled: boolean;
-    dbHost: string;
-    dbDatabase: string;
-    dbPort: number;
-    codeGenLogin: string;
-    codeGenPassword: string;
-    migrationsLocation: string;
-    dbTrustServerCertificate: boolean;
-    coreSchema: string;
-    mjRepoUrl: string;
-} | undefined;
+/**
+ * Get validated config for commands that require database connection.
+ * Throws error if config is invalid.
+ */
+export declare const getValidatedConfig: () => MJConfig;
+/**
+ * Get optional config for commands that don't require database connection.
+ * Returns undefined if no config exists, or partial config if it exists.
+ */
+export declare const getOptionalConfig: () => Partial<MJConfig> | undefined;
+/**
+ * Legacy function for backward compatibility with codegen.
+ * Validates and returns updated config.
+ * Returns undefined silently if config is invalid (command will handle the error).
+ */
+export declare const updatedConfig: () => MJConfig | undefined;
 export declare const createFlywayUrl: (mjConfig: MJConfig) => string;
 export declare const getFlywayConfig: (mjConfig: MJConfig, tag?: string) => Promise<FlywayConfig>;
 export {};