norn-cli 2.3.0 → 2.4.0

package/out/cli/colors.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * CLI color utilities using chalk with NO_COLOR support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initColors = initColors;
+exports.getStatusColor = getStatusColor;
+exports.formatDuration = formatDuration;
+exports.line = line;
+exports.doubleLine = doubleLine;
+// Chalk v5 is ESM-only, so we need dynamic import
+let chalkInstance = null;
+async function getChalk() {
+    if (!chalkInstance) {
+        const chalk = await import('chalk');
+        chalkInstance = chalk.default;
+    }
+    return chalkInstance;
+}
+/**
+ * Check if colors should be disabled
+ * Respects NO_COLOR environment variable (https://no-color.org/)
+ */
+function shouldDisableColors() {
+    return (process.env.NO_COLOR !== undefined ||
+        process.env.FORCE_COLOR === '0' ||
+        !process.stdout.isTTY);
+}
+/**
+ * Create a no-op color function for when colors are disabled
+ */
+function noColor(text) {
+    return text;
+}
+/**
+ * Plain text colors (no ANSI codes)
+ */
+const plainColors = {
+    success: noColor,
+    error: noColor,
+    warning: noColor,
+    info: noColor,
+    dim: noColor,
+    bold: noColor,
+    httpSuccess: noColor,
+    httpRedirect: noColor,
+    httpClientError: noColor,
+    httpServerError: noColor,
+    url: noColor,
+    method: noColor,
+    duration: noColor,
+    header: noColor,
+    headerValue: noColor,
+    checkmark: '✓',
+    cross: '✗',
+    bullet: '•',
+    arrow: '→',
+};
+/**
+ * Initialize colors - call this once at CLI startup
+ */
+async function initColors() {
+    if (shouldDisableColors()) {
+        return plainColors;
+    }
+    const chalk = await getChalk();
+    return {
+        success: (text) => chalk.green(text),
+        error: (text) => chalk.red(text),
+        warning: (text) => chalk.yellow(text),
+        info: (text) => chalk.cyan(text),
+        dim: (text) => chalk.dim(text),
+        bold: (text) => chalk.bold(text),
+        httpSuccess: (text) => chalk.green(text),
+        httpRedirect: (text) => chalk.cyan(text),
+        httpClientError: (text) => chalk.red(text),
+        httpServerError: (text) => chalk.magenta(text),
+        url: (text) => chalk.underline(text),
+        method: (text) => chalk.bold.cyan(text),
+        duration: (text) => chalk.dim(text),
+        header: (text) => chalk.dim(text),
+        headerValue: (text) => chalk.dim(text),
+        checkmark: chalk.green('✓'),
+        cross: chalk.red('✗'),
+        bullet: chalk.dim('•'),
+        arrow: chalk.dim('→'),
+    };
+}
+/**
+ * Get HTTP status color based on status code
+ */
+function getStatusColor(colors, status) {
+    if (status >= 200 && status < 300) {
+        return colors.httpSuccess;
+    }
+    else if (status >= 300 && status < 400) {
+        return colors.httpRedirect;
+    }
+    else if (status >= 400 && status < 500) {
+        return colors.httpClientError;
+    }
+    else {
+        return colors.httpServerError;
+    }
+}
+/**
+ * Format duration in human-readable form
+ */
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+/**
+ * Create a horizontal line
+ */
+function line(char = '─', length = 50) {
+    return char.repeat(length);
+}
+/**
+ * Create a double horizontal line
+ */
+function doubleLine(length = 50) {
+    return '═'.repeat(length);
+}
+//# sourceMappingURL=colors.js.map

package/out/cli/formatters/assertion.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Assertion formatter for CLI output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAssertion = formatAssertion;
+exports.formatAssertionSummary = formatAssertionSummary;
+const contractAssertionSummary_1 = require("../../contractAssertionSummary");
+/**
+ * Format a single assertion result
+ */
+function formatAssertion(assertion, options) {
+    const { colors, verbose } = options;
+    const lines = [];
+    const icon = assertion.passed ? colors.checkmark : colors.cross;
+    // Build display expression with friendly name when available
+    let displayExpr = assertion.expression;
+    if (assertion.friendlyName && assertion.responseIndex) {
+        // Replace $N with the friendly variable name
+        displayExpr = displayExpr.replace('$' + assertion.responseIndex, assertion.friendlyName);
+    }
+    const displayMessage = assertion.message || displayExpr;
+    const contractDisplay = (0, contractAssertionSummary_1.buildContractAssertionDisplay)(assertion);
+    if (contractDisplay) {
+        const summaryColor = assertion.passed ? colors.success : colors.warning;
+        lines.push(`${icon} ${summaryColor(contractDisplay.titleText)}`);
+        if (assertion.message) {
+            lines.push(`    ${colors.dim('Note:')} ${assertion.message}`);
+        }
+        if (verbose && contractDisplay.schemaPath && contractDisplay.schemaPath !== contractDisplay.schemaName) {
+            lines.push(`    ${colors.dim('Schema path:')} ${contractDisplay.schemaPath}`);
+        }
+        if (!assertion.passed) {
+            if (contractDisplay.issueTexts.length > 0) {
+                lines.push(`    ${colors.dim('Issues:')}`);
+                for (const issue of contractDisplay.issueTexts) {
+                    lines.push(`      ${colors.cross} ${colors.error(issue)}`);
+                }
+                if (contractDisplay.remainingIssueCount > 0) {
+                    lines.push(`      ${colors.dim(`+${contractDisplay.remainingIssueCount} more`)}`);
+                }
+            }
+            else if (assertion.error) {
+                lines.push(`    ${colors.error(`Error: ${assertion.error}`)}`);
+            }
+        }
+        return lines;
+    }
+    lines.push(`${icon} assert ${displayMessage}`);
+    // Show details for failures, or for all assertions in verbose mode
+    if (!assertion.passed || verbose) {
+        if (assertion.error) {
+            lines.push(`    ${colors.error(`Error: ${assertion.error}`)}`);
+        }
+        else if (!assertion.passed) {
+            // Show expected vs actual for failures
+            lines.push(`    ${colors.dim('Expected:')} ${formatValue(assertion.rightExpression ?? assertion.operator)}`);
+            lines.push(`    ${colors.dim('Actual:')} ${formatValue(assertion.leftValue)}`);
+            // If expressions differ from values, show original expressions
+            if (verbose && assertion.leftExpression !== String(assertion.leftValue)) {
+                lines.push(`    ${colors.dim('Expression:')} ${assertion.leftExpression}`);
+            }
+        }
+        else if (verbose) {
+            // In verbose mode, show values for passing assertions too
+            lines.push(`    ${colors.dim('Value:')} ${formatValue(assertion.leftValue)}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Format a value for display (handles objects, arrays, primitives)
+ */
+function formatValue(value) {
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+/**
+ * Format assertion summary (passed/failed counts)
+ */
+function formatAssertionSummary(results, colors) {
+    const passed = results.filter(a => a.passed).length;
+    const failed = results.length - passed;
+    if (failed > 0) {
+        return `${colors.error(`${passed}/${results.length} assertions passed`)} (${failed} failed)`;
+    }
+    return `${colors.success(`${passed}/${results.length} assertions passed`)}`;
+}
+//# sourceMappingURL=assertion.js.map

package/out/cli/formatters/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * CLI formatters index - re-exports all formatter functions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./response"), exports);
+__exportStar(require("./assertion"), exports);
+__exportStar(require("./summary"), exports);
+//# sourceMappingURL=index.js.map

package/out/cli/formatters/response.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * HTTP Response formatter for CLI output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatResponse = formatResponse;
+exports.formatResponseCompact = formatResponseCompact;
+const colors_1 = require("../colors");
+const redaction_1 = require("../redaction");
+/**
+ * Format a single HTTP response for CLI output
+ */
+function formatResponse(response, options) {
+    const { colors, redaction, verbose, showDetails, index, method, url } = options;
+    const lines = [];
+    const prefix = index !== undefined ? `[${index}] ` : '';
+    const statusColor = (0, colors_1.getStatusColor)(colors, response.status);
+    const isSuccess = response.status >= 200 && response.status < 300;
+    const icon = isSuccess ? colors.checkmark : colors.cross;
+    // Status line with optional method/url
+    if (method && url) {
+        const displayUrl = (0, redaction_1.redactUrl)(url, redaction);
+        const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1
+            ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}`
+            : '';
+        lines.push(`${prefix}${icon} ${colors.method(method)} ${displayUrl} ` +
+            `${statusColor(`(${response.status} ${response.statusText})`)} ` +
+            `${colors.duration((0, colors_1.formatDuration)(response.duration))}${retryInfo}`);
+    }
+    else {
+        const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1
+            ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}`
+            : '';
+        lines.push(`${prefix}${statusColor(`${response.status} ${response.statusText}`)} ` +
+            `${colors.duration(`(${(0, colors_1.formatDuration)(response.duration)})`)}${retryInfo}`);
+    }
+    // Only show details in verbose mode OR when there's an error/showDetails is true
+    if (verbose || showDetails) {
+        lines.push((0, colors_1.line)());
+        // Request details (if available and showing details)
+        if (showDetails && (options.requestHeaders || options.requestBody)) {
+            lines.push(colors.bold('Request:'));
+            if (options.requestHeaders) {
+                const redactedHeaders = (0, redaction_1.redactHeaders)(options.requestHeaders, redaction);
+                for (const [key, value] of Object.entries(redactedHeaders)) {
+                    lines.push(`  ${colors.header(key)}: ${colors.headerValue(value)}`);
+                }
+            }
+            if (options.requestBody) {
+                lines.push('');
+                lines.push(colors.dim('  Body:'));
+                const redactedBody = (0, redaction_1.redactBody)(options.requestBody, redaction);
+                const bodyStr = typeof redactedBody === 'object'
+                    ? JSON.stringify(redactedBody, null, 2)
+                    : String(redactedBody);
+                for (const bodyLine of bodyStr.split('\n')) {
+                    lines.push(`  ${colors.dim(bodyLine)}`);
+                }
+            }
+            lines.push('');
+            lines.push(colors.bold('Response:'));
+        }
+        // Response headers (verbose or on error)
+        if (verbose && response.headers) {
+            lines.push(colors.dim('Headers:'));
+            const redactedHeaders = (0, redaction_1.redactHeaders)(response.headers, redaction);
+            for (const [key, value] of Object.entries(redactedHeaders)) {
+                lines.push(`  ${colors.header(key)}: ${colors.headerValue(value)}`);
+            }
+            lines.push((0, colors_1.line)());
+        }
+        // Response body
+        if (response.body !== undefined && response.body !== null) {
+            const redactedBody = (0, redaction_1.redactBody)(response.body, redaction);
+            if (typeof redactedBody === 'object') {
+                lines.push(JSON.stringify(redactedBody, null, 2));
+            }
+            else {
+                lines.push(String(redactedBody));
+            }
+        }
+    }
+    return lines;
+}
+/**
+ * Format a compact one-line response (for quiet mode on success)
+ */
+function formatResponseCompact(response, options) {
+    const { colors, redaction, method, url, index } = options;
+    const prefix = index !== undefined ? `[${index}] ` : '';
+    const statusColor = (0, colors_1.getStatusColor)(colors, response.status);
+    const isSuccess = response.status >= 200 && response.status < 300;
+    const icon = isSuccess ? colors.checkmark : colors.cross;
+    const retryInfo = response.retryInfo && response.retryInfo.attemptsMade > 1
+        ? ` ${colors.warning(`[retried ${response.retryInfo.attemptsMade - 1}x]`)}`
+        : '';
+    if (method && url) {
+        const displayUrl = (0, redaction_1.redactUrl)(url, redaction);
+        return (`${prefix}${icon} ${colors.method(method)} ${displayUrl} ` +
+            `${statusColor(`${response.status}`)} ` +
+            `${colors.duration((0, colors_1.formatDuration)(response.duration))}${retryInfo}`);
+    }
+    return (`${prefix}${icon} ${statusColor(`${response.status} ${response.statusText}`)} ` +
+        `${colors.duration((0, colors_1.formatDuration)(response.duration))}${retryInfo}`);
+}
+//# sourceMappingURL=response.js.map

package/out/cli/formatters/summary.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Summary formatter for CLI output - formats sequence results and overall run summaries
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSequenceResult = formatSequenceResult;
+exports.formatRunSummary = formatRunSummary;
+exports.formatProgressLine = formatProgressLine;
+const colors_1 = require("../colors");
+const response_1 = require("./response");
+const assertion_1 = require("./assertion");
+/**
+ * Format a single sequence result
+ */
+function formatSequenceResult(result, options) {
+    const { colors, redaction, verbose } = options;
+    const lines = [];
+    // Sequence header
+    const statusIcon = result.success ? colors.checkmark : colors.cross;
+    const statusColor = result.success ? colors.success : colors.error;
+    lines.push('');
+    lines.push(`${statusIcon} ${statusColor(`Sequence: ${result.name}`)}`);
+    lines.push(`${colors.dim('Duration:')} ${(0, colors_1.formatDuration)(result.duration)}`);
+    // Assertion summary if any
+    if (result.assertionResults && result.assertionResults.length > 0) {
+        lines.push(`${colors.dim('Assertions:')} ${(0, assertion_1.formatAssertionSummary)(result.assertionResults, colors)}`);
+    }
+    // Request count
+    const requestCount = result.steps.filter(s => s.type === 'request').length;
+    lines.push(`${colors.dim('Requests:')} ${requestCount}`);
+    const mcpCount = result.steps.filter(s => s.type === 'mcp').length;
+    if (mcpCount > 0) {
+        lines.push(`${colors.dim('MCP steps:')} ${mcpCount}`);
+    }
+    lines.push((0, colors_1.doubleLine)());
+    // Track if we've shown any expanded details
+    let requestIdx = 0;
+    // Print steps in order
+    for (const step of result.steps) {
+        const stepLines = formatStep(step, {
+            colors,
+            redaction,
+            verbose,
+            requestIndex: step.type === 'request' ? ++requestIdx : undefined,
+        });
+        lines.push(...stepLines);
+    }
+    // Show accumulated errors/warnings at the end
+    if (result.errors.length > 0) {
+        lines.push('');
+        lines.push(colors.warning('Warnings/Errors:'));
+        for (const err of result.errors) {
+            const errLines = String(err ?? '').split('\n');
+            if (errLines.length === 0) {
+                continue;
+            }
+            lines.push(`  ${colors.bullet} ${errLines[0]}`);
+            for (const line of errLines.slice(1)) {
+                lines.push(`    ${line}`);
+            }
+        }
+    }
+    return lines;
+}
+/**
+ * Format a single step result
+ */
+function formatStep(step, options) {
+    const { colors, redaction, verbose, requestIndex } = options;
+    switch (step.type) {
+        case 'print':
+            return formatPrintStep(step, colors);
+        case 'request':
+            return formatRequestStep(step, { colors, redaction, verbose, requestIndex });
+        case 'assertion':
+            return formatAssertionStep(step, { colors, verbose });
+        case 'script':
+            return formatScriptStep(step, colors, verbose);
+        case 'json':
+            return formatJsonStep(step, colors, verbose);
+        case 'sql':
+            return formatSqlStep(step, colors, verbose);
+        case 'mcp':
+            return formatMcpStep(step, colors, verbose);
+        default:
+            return [];
+    }
+}
+function formatPrintStep(step, colors) {
+    const lines = [];
+    if (step.print) {
+        lines.push(`${colors.warning('[print]')} ${step.print.title}`);
+        if (step.print.body) {
+            lines.push(`        ${step.print.body}`);
+        }
+    }
+    return lines;
+}
+function formatRequestStep(step, options) {
+    const { colors, redaction, verbose, requestIndex } = options;
+    if (!step.response) {
+        return [];
+    }
+    const isSuccess = step.response.status >= 200 && step.response.status < 300;
+    // In quiet mode (not verbose), only show compact line for successful requests
+    // Show full details for failures
+    if (!verbose && isSuccess) {
+        return [(0, response_1.formatResponseCompact)(step.response, {
+                colors,
+                redaction,
+                method: step.requestMethod,
+                url: step.requestUrl,
+                index: requestIndex,
+            })];
+    }
+    // Show full details for failures or in verbose mode
+    return (0, response_1.formatResponse)(step.response, {
+        colors,
+        redaction,
+        verbose,
+        showDetails: !isSuccess || verbose, // Show request details on failure or verbose
+        index: requestIndex,
+        method: step.requestMethod,
+        url: step.requestUrl,
+        requestBody: step.response.requestBody,
+        requestHeaders: step.response.requestHeaders,
+    });
+}
+function formatAssertionStep(step, options) {
+    if (!step.assertion) {
+        return [];
+    }
+    return (0, assertion_1.formatAssertion)(step.assertion, {
+        colors: options.colors,
+        verbose: options.verbose,
+    });
+}
+function formatScriptStep(step, colors, verbose) {
+    const lines = [];
+    if (step.script) {
+        const icon = step.script.success ? colors.checkmark : colors.cross;
+        lines.push(`${icon} ${colors.dim('[script]')} ${step.script.type}`);
+        if (!step.script.success || verbose) {
+            if (step.script.error) {
+                lines.push(`    ${colors.error(`Error: ${step.script.error}`)}`);
+            }
+            if (verbose && step.script.output) {
+                lines.push(`    ${colors.dim('output:')} ${step.script.output}`);
+            }
+        }
+    }
+    return lines;
+}
+function formatJsonStep(step, colors, verbose) {
+    const lines = [];
+    if (step.json) {
+        const icon = step.json.success ? colors.checkmark : colors.cross;
+        lines.push(`${icon} ${colors.dim('[json]')} Loaded: ${step.json.varName}`);
+        if (!step.json.success) {
+            lines.push(`    ${colors.error(`Error: ${step.json.error}`)}`);
+        }
+        else if (verbose) {
+            lines.push(`    ${colors.dim('File:')} ${step.json.filePath}`);
+        }
+    }
+    return lines;
+}
+function formatSqlStep(step, colors, verbose) {
+    const lines = [];
+    if (!step.sql) {
+        return lines;
+    }
+    const icon = colors.checkmark;
+    if (step.sql.operationType === 'query') {
+        lines.push(`${icon} ${colors.dim('[sql]')} ${step.sql.operationName} (${step.sql.rowCount ?? 0} rows)`);
+        if (verbose && step.variableName) {
+            lines.push(`    ${colors.dim('captured as:')} ${step.variableName}`);
+        }
+    }
+    else {
+        lines.push(`${icon} ${colors.dim('[sql]')} ${step.sql.operationName} (${step.sql.affectedRows ?? 0} affected)`);
+        if (verbose && step.variableName) {
+            lines.push(`    ${colors.dim('captured as:')} ${step.variableName}`);
+        }
+    }
+    return lines;
+}
+function formatMcpStep(step, colors, verbose) {
+    const lines = [];
+    if (!step.mcp) {
+        return lines;
+    }
+    if (step.mcp.operation === 'list') {
+        lines.push(`${colors.checkmark} ${colors.dim('[mcp]')} list ${step.mcp.serverAlias} (${step.mcp.tools?.length || 0} tools)`);
+        if (verbose && step.variableName) {
+            lines.push(`    ${colors.dim('captured as:')} ${step.variableName}`);
+        }
+        if (verbose && step.mcp.tools && step.mcp.tools.length > 0) {
+            lines.push(`    ${colors.dim('tools:')} ${step.mcp.tools.map(tool => tool.name).join(', ')}`);
+        }
+        return lines;
+    }
+    lines.push(`${colors.checkmark} ${colors.dim('[mcp]')} call ${step.mcp.serverAlias}.${step.mcp.toolName || ''}`);
+    if (verbose && step.variableName) {
+        lines.push(`    ${colors.dim('captured as:')} ${step.variableName}`);
+    }
+    if (verbose && step.mcp.result?.text) {
+        lines.push(`    ${colors.dim('text:')} ${step.mcp.result.text}`);
+    }
+    return lines;
+}
+/**
+ * Format the overall run summary (for multiple sequences)
+ */
+function formatRunSummary(results, totalDuration, colors) {
+    const lines = [];
+    const passed = results.filter(r => r.success).length;
+    const failed = results.length - passed;
+    lines.push('');
+    lines.push((0, colors_1.doubleLine)());
+    lines.push(colors.bold('Summary'));
+    lines.push((0, colors_1.line)());
+    lines.push(`${colors.dim('Total sequences:')} ${results.length}`);
+    lines.push(`${colors.success(`Passed: ${passed}`)}`);
+    if (failed > 0) {
+        lines.push(`${colors.error(`Failed: ${failed}`)}`);
+        // List failed sequences
+        lines.push('');
+        lines.push(colors.error('Failed sequences:'));
+        for (const result of results.filter(r => !r.success)) {
+            lines.push(`  ${colors.cross} ${result.name}`);
+        }
+    }
+    lines.push('');
+    lines.push(`${colors.dim('Total duration:')} ${(0, colors_1.formatDuration)(totalDuration)}`);
+    return lines;
+}
+/**
+ * Format a single-line progress indicator (for streaming output)
+ */
+function formatProgressLine(sequenceName, currentStep, totalSteps, stepDescription, colors) {
+    return (`${colors.info(`[${sequenceName}]`)} ` +
+        `${colors.dim(`Step ${currentStep}/${totalSteps}:`)} ` +
+        `${stepDescription}`);
+}
+//# sourceMappingURL=summary.js.map