norn-cli 2.4.0 → 2.6.0

package/out/assertionRunner.js

@@ -1,567 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAssertCommand = isAssertCommand;
-exports.parseAssertCommand = parseAssertCommand;
-exports.resolveValue = resolveValue;
-exports.evaluateAssertion = evaluateAssertion;
-const schemaGenerator_1 = require("./schemaGenerator");
-const pathAccess_1 = require("./pathAccess");
-const quotedString_1 = require("./quotedString");
-const parser_1 = require("./parser");
-/**
- * Checks if a line is an assert command
- */
-function isAssertCommand(line) {
-    return /^assert\s+/i.test(line.trim());
-}
-/**
- * Parses an assert command line.
- *
- * Supported formats:
- * - assert $1.status == 200
- * - assert $1.body.name == "John"
- * - assert $1.body.email contains "@"
- * - assert $1.body.token exists
- * - assert $1.status >= 200 | "Should return success status"
- *
- * @param line The assert command line
- * @returns Parsed assertion or null if invalid
- */
-function parseAssertCommand(line) {
-    const trimmed = line.trim();
-    const match = trimmed.match(/^assert\s+(.+)$/i);
-    if (!match) {
-        return null;
-    }
-    let content = match[1].trim();
-    let message;
-    // Check for optional message after |
-    const pipeIndex = findUnquotedPipe(content);
-    if (pipeIndex !== -1) {
-        message = content.substring(pipeIndex + 1).trim();
-        // Remove surrounding quotes from message if present
-        if ((message.startsWith('"') && message.endsWith('"')) ||
-            (message.startsWith("'") && message.endsWith("'"))) {
-            message = (0, quotedString_1.decodeQuotedStringLiteral)(message);
-        }
-        content = content.substring(0, pipeIndex).trim();
-    }
-    // Try to parse unary operators first (exists, !exists)
-    const existsMatch = content.match(/^(.+?)\s+(exists|!exists)$/i);
-    if (existsMatch) {
-        return {
-            leftExpr: existsMatch[1].trim(),
-            operator: existsMatch[2].toLowerCase(),
-            message
-        };
-    }
-    // Parse binary operators
-    // Order matters: check multi-char operators first
-    const binaryOperators = [
-        { pattern: /^(.+?)\s*>=\s*(.+)$/, op: '>=' },
-        { pattern: /^(.+?)\s*<=\s*(.+)$/, op: '<=' },
-        { pattern: /^(.+?)\s*==\s*(.+)$/, op: '==' },
-        { pattern: /^(.+?)\s*!=\s*(.+)$/, op: '!=' },
-        { pattern: /^(.+?)\s*>\s*(.+)$/, op: '>' },
-        { pattern: /^(.+?)\s*<\s*(.+)$/, op: '<' },
-        { pattern: /^(.+?)\s+contains\s+(.+)$/i, op: 'contains' },
-        { pattern: /^(.+?)\s+startsWith\s+(.+)$/i, op: 'startsWith' },
-        { pattern: /^(.+?)\s+endsWith\s+(.+)$/i, op: 'endsWith' },
-        { pattern: /^(.+?)\s+matches\s+(.+)$/i, op: 'matches' },
-        { pattern: /^(.+?)\s+matchesSchema\s+(.+)$/i, op: 'matchesSchema' },
-        { pattern: /^(.+?)\s+isType\s+(.+)$/i, op: 'isType' },
-    ];
-    for (const { pattern, op } of binaryOperators) {
-        const binaryMatch = content.match(pattern);
-        if (binaryMatch) {
-            return {
-                leftExpr: binaryMatch[1].trim(),
-                operator: op,
-                rightExpr: binaryMatch[2].trim(),
-                message
-            };
-        }
-    }
-    return null;
-}
-/**
- * Find the index of an unquoted pipe character
- */
-function findUnquotedPipe(str) {
-    let inQuote = false;
-    let quoteChar = '';
-    let escapeNext = false;
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        if (escapeNext) {
-            escapeNext = false;
-            continue;
-        }
-        if (inQuote && char === '\\') {
-            escapeNext = true;
-            continue;
-        }
-        if ((char === '"' || char === "'") && !inQuote) {
-            inQuote = true;
-            quoteChar = char;
-        }
-        else if (char === quoteChar && inQuote) {
-            inQuote = false;
-            quoteChar = '';
-        }
-        else if (char === '|' && !inQuote) {
-            return i;
-        }
-    }
-    return -1;
-}
-/**
- * Resolves a value expression to its actual value.
- *
- * Supports:
- * - $N.path references (e.g., $1.status, $1.body.user.id)
- * - String literals ("hello" or 'hello')
- * - Number literals (200, 3.14)
- * - Boolean literals (true, false)
- * - null
- * - Variable references {{varName}}
- *
- * @param expr The expression to resolve
- * @param responses Array of responses from the sequence (indexed by $N where N is 1-based)
- * @param variables Current runtime variables
- * @param getValueByPath Function to extract value from response
- * @param responseIndexToVariable Optional mapping from response index to variable name
- */
-function resolveValue(expr, responses, variables, getValueByPath, responseIndexToVariable) {
-    const trimmed = expr.trim();
-    const wrappedResponseRefMatch = trimmed.match(/^\{\{(\$\d+(?:\..+)?)\}\}$/);
-    if (wrappedResponseRefMatch) {
-        return resolveValue(wrappedResponseRefMatch[1], responses, variables, getValueByPath, responseIndexToVariable);
-    }
-    // Check for $N.path reference
-    const refMatch = trimmed.match(/^\$(\d+)\.(.+)$/);
-    if (refMatch) {
-        const responseIdx = parseInt(refMatch[1], 10); // Keep 1-based for tracking
-        const responseIndex = responseIdx - 1; // Convert to 0-based for array access
-        const path = refMatch[2];
-        if (responseIndex < 0 || responseIndex >= responses.length) {
-            return {
-                value: undefined,
-                error: `Response $${refMatch[1]} does not exist (only ${responses.length} responses so far)`
-            };
-        }
-        const response = responses[responseIndex];
-        const value = getValueByPath(response, path);
-        return {
-            value,
-            responseIndex: responseIdx,
-            response,
-            jsonPath: path,
-            variableName: responseIndexToVariable?.get(responseIdx)
-        };
-    }
-    // Check for $N without path (invalid in new syntax)
-    if (/^\$\d+$/.test(trimmed)) {
-        return {
-            value: undefined,
-            error: `Invalid reference: ${trimmed}. Use $N.body for full body or $N.status, $N.headers, etc.`
-        };
-    }
-    // Check for variable.path reference (e.g., user.body.username where user is a captured response)
-    const varPathMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])+)$/);
-    if (varPathMatch) {
-        const varName = varPathMatch[1];
-        const pathPart = varPathMatch[2];
-        if (varName in variables) {
-            const varValue = variables[varName];
-            // If the variable is an object (like HttpResponse), navigate the path
-            if (typeof varValue === 'object' && varValue !== null) {
-                const path = pathPart.replace(/^\./, ''); // Remove leading dot
-                const value = getNestedValue(varValue, path);
-                // Check if this looks like an HttpResponse (has status and body)
-                const isHttpResponse = 'status' in varValue && 'body' in varValue;
-                return {
-                    value,
-                    variableName: varName,
-                    jsonPath: path,
-                    response: isHttpResponse ? varValue : undefined
-                };
-            }
-            // If it's a string, try to parse as JSON
-            if (typeof varValue === 'string') {
-                try {
-                    const parsed = JSON.parse(varValue);
-                    const path = pathPart.replace(/^\./, '');
-                    const value = getNestedValue(parsed, path);
-                    return { value, variableName: varName, jsonPath: path };
-                }
-                catch {
-                    return { value: undefined, error: `Cannot access path on non-object variable: ${varName}` };
-                }
-            }
-        }
-        return { value: undefined, error: `Variable '${varName}' is not defined` };
-    }
-    // Check for simple variable reference (no path) - e.g., just "user" or "token"
-    const simpleVarMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
-    if (simpleVarMatch) {
-        const varName = simpleVarMatch[1];
-        // Don't treat type keywords as variables
-        if (!['true', 'false', 'null', 'string', 'number', 'boolean', 'object', 'array', 'undefined'].includes(varName.toLowerCase())) {
-            if (varName in variables) {
-                const varValue = variables[varName];
-                // Try to parse numbers
-                if (typeof varValue === 'string' && /^-?\d+(\.\d+)?$/.test(varValue)) {
-                    return { value: parseFloat(varValue) };
-                }
-                return { value: varValue };
-            }
-            // Variable not found - but could also be a type name for isType, so don't error here
-        }
-    }
-    // Check for variable reference {{varName}}, {{varName.path}}, or {{$env.name}}
-    const varMatch = trimmed.match(/^\{\{(\$env|[a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)\}\}$/);
-    if (varMatch) {
-        const varName = varMatch[1];
-        const pathPart = varMatch[2] || '';
-        if (varName in variables) {
-            const varValue = variables[varName];
-            if (pathPart) {
-                if (typeof varValue === 'object' && varValue !== null) {
-                    const path = pathPart.replace(/^\./, '');
-                    return { value: getNestedValue(varValue, path) };
-                }
-                if (typeof varValue === 'string') {
-                    try {
-                        const parsed = JSON.parse(varValue);
-                        const path = pathPart.replace(/^\./, '');
-                        return { value: getNestedValue(parsed, path) };
-                    }
-                    catch {
-                        return { value: undefined, error: `Cannot access path on non-object variable: ${varName}` };
-                    }
-                }
-                return { value: undefined, error: `Cannot access path on non-object variable: ${varName}` };
-            }
-            if (typeof varValue === 'string' && /^-?\d+(\.\d+)?$/.test(varValue)) {
-                return { value: parseFloat(varValue) };
-            }
-            return { value: varValue };
-        }
-        return { value: undefined, error: `Variable {{${varName}}} is not defined` };
-    }
-    // Check for string literal
-    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-        return { value: (0, parser_1.substituteVariables)((0, quotedString_1.decodeQuotedStringLiteral)(trimmed), variables) };
-    }
-    // Check for number literal
-    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-        return { value: parseFloat(trimmed) };
-    }
-    // Check for boolean literals
-    if (trimmed.toLowerCase() === 'true') {
-        return { value: true };
-    }
-    if (trimmed.toLowerCase() === 'false') {
-        return { value: false };
-    }
-    // Check for null
-    if (trimmed.toLowerCase() === 'null') {
-        return { value: null };
-    }
-    // Check for empty array literal
-    if (trimmed === '[]') {
-        return { value: [] };
-    }
-    // Check for empty object literal
-    if (trimmed === '{}') {
-        return { value: {} };
-    }
-    // Unknown expression type
-    return { value: undefined, error: `Cannot resolve expression: ${trimmed}` };
-}
-/**
- * Helper function to get nested value from an object using dot notation path
- */
-function getNestedValue(obj, path) {
-    return (0, pathAccess_1.getNestedPathValue)(obj, path);
-}
-function areValuesEqual(leftValue, rightValue) {
-    if (leftValue === rightValue) {
-        return true;
-    }
-    if (leftValue === null || rightValue === null || leftValue === undefined || rightValue === undefined) {
-        return leftValue === rightValue;
-    }
-    const leftIsArray = Array.isArray(leftValue);
-    const rightIsArray = Array.isArray(rightValue);
-    if (leftIsArray || rightIsArray) {
-        if (!leftIsArray || !rightIsArray) {
-            return false;
-        }
-        if (leftValue.length !== rightValue.length) {
-            return false;
-        }
-        for (let i = 0; i < leftValue.length; i++) {
-            if (!areValuesEqual(leftValue[i], rightValue[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    const leftIsObject = typeof leftValue === 'object';
-    const rightIsObject = typeof rightValue === 'object';
-    if (leftIsObject || rightIsObject) {
-        if (!leftIsObject || !rightIsObject) {
-            return false;
-        }
-        const leftKeys = Object.keys(leftValue);
-        const rightKeys = Object.keys(rightValue);
-        if (leftKeys.length !== rightKeys.length) {
-            return false;
-        }
-        for (const key of leftKeys) {
-            if (!Object.prototype.hasOwnProperty.call(rightValue, key)) {
-                return false;
-            }
-            if (!areValuesEqual(leftValue[key], rightValue[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // Preserve assertion language coercion after structural checks, e.g. "200" equals 200.
-    // eslint-disable-next-line eqeqeq
-    return leftValue == rightValue;
-}
-/**
- * Evaluates an assertion.
- *
- * @param assertion Parsed assertion
- * @param responses Array of responses from the sequence
- * @param variables Current runtime variables (can contain objects like HttpResponse)
- * @param getValueByPath Function to extract value from response
- * @param responseIndexToVariable Optional mapping from response index (1-based) to variable name
- * @param basePath Optional base path for resolving relative schema file paths
- */
-function evaluateAssertion(assertion, responses, variables, getValueByPath, responseIndexToVariable, basePath) {
-    const leftResult = resolveValue(assertion.leftExpr, responses, variables, getValueByPath, responseIndexToVariable);
-    const message = assertion.message === undefined ? undefined : (0, parser_1.substituteVariables)(assertion.message, variables);
-    const expression = formatExpression(assertion, variables);
-    // Helper to build failure context from left result
-    const buildFailureContext = () => ({
-        responseIndex: leftResult.responseIndex,
-        friendlyName: leftResult.variableName,
-        relatedResponse: leftResult.response,
-        jsonPath: leftResult.jsonPath
-    });
-    // Handle resolution errors
-    if (leftResult.error) {
-        return {
-            passed: false,
-            expression,
-            message,
-            operator: assertion.operator,
-            leftValue: undefined,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            error: leftResult.error,
-            ...buildFailureContext()
-        };
-    }
-    const leftValue = leftResult.value;
-    // Handle unary operators
-    if (assertion.operator === 'exists') {
-        const passed = leftValue !== undefined && leftValue !== null;
-        return {
-            passed,
-            expression,
-            message,
-            operator: assertion.operator,
-            leftValue,
-            leftExpression: assertion.leftExpr,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    if (assertion.operator === '!exists') {
-        const passed = leftValue === undefined || leftValue === null;
-        return {
-            passed,
-            expression,
-            message,
-            operator: assertion.operator,
-            leftValue,
-            leftExpression: assertion.leftExpr,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    // Binary operators require right expression
-    if (!assertion.rightExpr) {
-        return {
-            passed: false,
-            expression,
-            message,
-            operator: assertion.operator,
-            leftValue,
-            leftExpression: assertion.leftExpr,
-            error: `Operator ${assertion.operator} requires a right-hand value`,
-            ...buildFailureContext()
-        };
-    }
-    // For isType operator, the right side is a literal type name, not a value to resolve
-    if (assertion.operator === 'isType') {
-        const expectedType = assertion.rightExpr.toLowerCase();
-        let actualType;
-        if (leftValue === null) {
-            actualType = 'null';
-        }
-        else if (Array.isArray(leftValue)) {
-            actualType = 'array';
-        }
-        else {
-            actualType = typeof leftValue;
-        }
-        const passed = actualType === expectedType;
-        return {
-            passed,
-            expression,
-            message,
-            operator: assertion.operator,
-            leftValue,
-            rightValue: expectedType,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    // For matchesSchema operator, validate against a JSON Schema file
-    if (assertion.operator === 'matchesSchema') {
-        // Right side is a file path (with or without quotes)
-        let schemaPath = assertion.rightExpr;
-        // Remove surrounding quotes if present
-        if ((schemaPath.startsWith('"') && schemaPath.endsWith('"')) ||
-            (schemaPath.startsWith("'") && schemaPath.endsWith("'"))) {
-            schemaPath = schemaPath.slice(1, -1);
-        }
-        schemaPath = (0, parser_1.substituteVariables)(schemaPath, variables);
-        const validationResult = (0, schemaGenerator_1.validateAgainstSchemaDetailed)(leftValue, schemaPath, basePath);
-        const passed = validationResult.valid;
-        return {
-            passed,
-            expression,
-            message,
-            operator: assertion.operator,
-            leftValue,
-            rightValue: schemaPath,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            error: !passed && validationResult.errorStrings ? validationResult.errorStrings.join('; ') : undefined,
-            schemaErrors: validationResult.errors,
-            schemaPath: validationResult.resolvedSchemaPath,
-            schema: validationResult.schema,
-            schemaSummary: validationResult.summary,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    const rightResult = resolveValue(assertion.rightExpr, responses, variables, getValueByPath, responseIndexToVariable);
-    if (rightResult.error) {
-        return {
-            passed: false,
-            expression,
-            message,
-            operator: assertion.operator,
-            leftValue,
-            rightValue: undefined,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            error: rightResult.error,
-            ...buildFailureContext()
-        };
-    }
-    const rightValue = rightResult.value;
-    let passed = false;
-    switch (assertion.operator) {
-        case '==':
-            passed = areValuesEqual(leftValue, rightValue);
-            break;
-        case '!=':
-            passed = !areValuesEqual(leftValue, rightValue);
-            break;
-        case '>':
-            passed = Number(leftValue) > Number(rightValue);
-            break;
-        case '>=':
-            passed = Number(leftValue) >= Number(rightValue);
-            break;
-        case '<':
-            passed = Number(leftValue) < Number(rightValue);
-            break;
-        case '<=':
-            passed = Number(leftValue) <= Number(rightValue);
-            break;
-        case 'contains':
-            passed = String(leftValue).includes(String(rightValue));
-            break;
-        case 'startsWith':
-            passed = String(leftValue).startsWith(String(rightValue));
-            break;
-        case 'endsWith':
-            passed = String(leftValue).endsWith(String(rightValue));
-            break;
-        case 'matches':
-            try {
-                // Remove regex delimiters if present
-                let pattern = String(rightValue);
-                if (pattern.startsWith('/') && pattern.lastIndexOf('/') > 0) {
-                    const lastSlash = pattern.lastIndexOf('/');
-                    const flags = pattern.substring(lastSlash + 1);
-                    pattern = pattern.substring(1, lastSlash);
-                    passed = new RegExp(pattern, flags).test(String(leftValue));
-                }
-                else {
-                    passed = new RegExp(pattern).test(String(leftValue));
-                }
-            }
-            catch (e) {
-                return {
-                    passed: false,
-                    expression,
-                    message,
-                    operator: assertion.operator,
-                    leftValue,
-                    rightValue,
-                    leftExpression: assertion.leftExpr,
-                    rightExpression: assertion.rightExpr,
-                    error: `Invalid regex pattern: ${rightValue}`,
-                    ...buildFailureContext()
-                };
-            }
-            break;
-        // Note: isType is handled earlier before resolveValue is called
-    }
-    return {
-        passed,
-        expression,
-        message,
-        operator: assertion.operator,
-        leftValue,
-        rightValue,
-        leftExpression: assertion.leftExpr,
-        rightExpression: assertion.rightExpr,
-        ...(!passed ? buildFailureContext() : {})
-    };
-}
-/**
- * Format the assertion expression for display
- */
-function formatExpression(assertion, variables) {
-    if (assertion.rightExpr) {
-        return substituteAssertionDisplayTemplates(`${assertion.leftExpr} ${assertion.operator} ${assertion.rightExpr}`, variables);
-    }
-    return substituteAssertionDisplayTemplates(`${assertion.leftExpr} ${assertion.operator}`, variables);
-}
-function substituteAssertionDisplayTemplates(expression, variables) {
-    return variables ? (0, parser_1.substituteVariables)(expression, variables) : expression;
-}
-//# sourceMappingURL=assertionRunner.js.map

package/out/cacheDir.js

@@ -1,136 +0,0 @@
-"use strict";
-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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NORN_CACHE_DIR = void 0;
-exports.getSearchStartDirectory = getSearchStartDirectory;
-exports.findProjectRoot = findProjectRoot;
-exports.ensureNornCacheGitignore = ensureNornCacheGitignore;
-exports.ensureNornCacheDir = ensureNornCacheDir;
-exports.getNornCacheFilePath = getNornCacheFilePath;
-exports.loadVersionedJsonCache = loadVersionedJsonCache;
-exports.saveVersionedJsonCache = saveVersionedJsonCache;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-exports.NORN_CACHE_DIR = '.norn-cache';
-const CACHE_GITIGNORE_FILE = '.gitignore';
-const CACHE_GITIGNORE_CONTENT = '*\n';
-const PROJECT_ROOT_MARKERS = ['.git', 'package.json', 'pnpm-workspace.yaml', 'package-lock.json', 'yarn.lock', '.nornenv'];
-function getSearchStartDirectory(targetPath) {
-    const resolvedPath = path.resolve(targetPath);
-    try {
-        const stats = fs.statSync(resolvedPath);
-        return stats.isDirectory() ? resolvedPath : path.dirname(resolvedPath);
-    }
-    catch {
-        return path.dirname(resolvedPath);
-    }
-}
-function findProjectRoot(targetPath) {
-    let dir = getSearchStartDirectory(targetPath);
-    let projectRoot;
-    while (true) {
-        if (PROJECT_ROOT_MARKERS.some(marker => fs.existsSync(path.join(dir, marker)))) {
-            projectRoot = dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir) {
-            break;
-        }
-        dir = parent;
-    }
-    return projectRoot ?? getSearchStartDirectory(targetPath);
-}
-function ensureNornCacheGitignore(cacheDir) {
-    const gitignorePath = path.join(cacheDir, CACHE_GITIGNORE_FILE);
-    try {
-        const hasDesiredContent = fs.existsSync(gitignorePath)
-            && fs.readFileSync(gitignorePath, 'utf8') === CACHE_GITIGNORE_CONTENT;
-        if (hasDesiredContent) {
-            return;
-        }
-        fs.writeFileSync(gitignorePath, CACHE_GITIGNORE_CONTENT, 'utf8');
-    }
-    catch {
-        // Best effort only; failure here should not block cache writes.
-    }
-}
-function ensureNornCacheDir(rootPath) {
-    const cacheDir = path.join(rootPath, exports.NORN_CACHE_DIR);
-    try {
-        if (!fs.existsSync(cacheDir)) {
-            fs.mkdirSync(cacheDir, { recursive: true });
-        }
-        ensureNornCacheGitignore(cacheDir);
-        return cacheDir;
-    }
-    catch {
-        return undefined;
-    }
-}
-function getNornCacheFilePath(rootPath, fileName) {
-    return path.join(rootPath, exports.NORN_CACHE_DIR, fileName);
-}
-function loadVersionedJsonCache(options) {
-    if (!options.cachePath || !fs.existsSync(options.cachePath)) {
-        return options.createDefault();
-    }
-    try {
-        const content = fs.readFileSync(options.cachePath, 'utf-8');
-        const parsed = JSON.parse(content);
-        if (parsed.version !== options.version) {
-            return options.createDefault();
-        }
-        if (options.isValid && !options.isValid(parsed)) {
-            return options.createDefault();
-        }
-        return parsed;
-    }
-    catch {
-        return options.createDefault();
-    }
-}
-function saveVersionedJsonCache(cachePath, cache, ensureDirectory) {
-    if (!cachePath || !ensureDirectory()) {
-        return false;
-    }
-    try {
-        fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=cacheDir.js.map