norn-cli 2.3.0 → 2.4.0

package/out/assertionRunner.js

@@ -0,0 +1,567 @@
+"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

@@ -0,0 +1,136 @@
+"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