norn-cli 2.3.0 → 2.4.0

package/out/postmanImportPlanner.js

@@ -0,0 +1,1155 @@
+"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.buildPostmanImportPlan = buildPostmanImportPlan;
+exports.writePostmanImportPlan = writePostmanImportPlan;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SUPPORTED_METHODS = new Set(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS']);
+const SECRET_NAME_REGEX = /(token|secret|password|passwd|pwd|api[_-]?key|access[_-]?key|client[_-]?secret|authorization)/i;
+function buildPostmanImportPlan(kind, sourceFilePaths, destinationFolder) {
+    const warnings = [];
+    const blockers = [];
+    const files = [];
+    if (sourceFilePaths.length === 0) {
+        blockers.push({ code: 'no-source', message: 'No Postman JSON file selected.' });
+        return {
+            kind,
+            summary: createEmptySummary(kind, destinationFolder, sourceFilePaths.length),
+            files,
+            warnings,
+            blockers,
+        };
+    }
+    if (kind === 'collection') {
+        const collectionPath = sourceFilePaths[0];
+        const build = buildCollectionImport(collectionPath, destinationFolder, warnings, blockers);
+        if (build) {
+            files.push(...build.files);
+            blockers.push(...collectCollisionBlockers(build.files));
+            return {
+                kind,
+                summary: {
+                    title: build.title,
+                    kind,
+                    sourceFileCount: 1,
+                    folderCount: build.folderCount,
+                    requestCount: build.requestCount,
+                    environmentCount: 0,
+                    variableCount: build.variableCount,
+                    secretCount: 0,
+                    fileCount: build.files.length,
+                    destinationFolder,
+                },
+                files: build.files,
+                warnings,
+                blockers,
+            };
+        }
+    }
+    else {
+        const build = buildEnvironmentImport(sourceFilePaths, destinationFolder, warnings, blockers);
+        if (build) {
+            files.push(build.file);
+            blockers.push(...collectCollisionBlockers([build.file]));
+            return {
+                kind,
+                summary: {
+                    title: build.title,
+                    kind,
+                    sourceFileCount: sourceFilePaths.length,
+                    folderCount: 0,
+                    requestCount: 0,
+                    environmentCount: build.environmentCount,
+                    variableCount: build.variableCount,
+                    secretCount: build.secretCount,
+                    fileCount: 1,
+                    destinationFolder,
+                },
+                files,
+                warnings,
+                blockers,
+            };
+        }
+    }
+    return {
+        kind,
+        summary: createEmptySummary(kind, destinationFolder, sourceFilePaths.length),
+        files,
+        warnings,
+        blockers,
+    };
+}
+function writePostmanImportPlan(plan) {
+    const result = {
+        createdFiles: [],
+        skippedFiles: [],
+    };
+    if (plan.blockers.length > 0) {
+        return {
+            createdFiles: result.createdFiles,
+            skippedFiles: result.skippedFiles,
+            warningCount: plan.warnings.length,
+        };
+    }
+    for (const file of plan.files) {
+        if (file.existsCollision && file.writeMode !== 'append') {
+            result.skippedFiles.push(file.relativePath);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(file.absolutePath), { recursive: true });
+        if (file.writeMode === 'append') {
+            const existingText = fs.existsSync(file.absolutePath) ? fs.readFileSync(file.absolutePath, 'utf8') : '';
+            const contentToAppend = existingText.length > 0 && !existingText.endsWith('\n')
+                ? `\n${file.content}`
+                : file.content;
+            fs.appendFileSync(file.absolutePath, contentToAppend, 'utf8');
+        }
+        else {
+            fs.writeFileSync(file.absolutePath, file.content, 'utf8');
+        }
+        result.createdFiles.push(file.relativePath);
+    }
+    return {
+        createdFiles: result.createdFiles,
+        skippedFiles: result.skippedFiles,
+        warningCount: plan.warnings.length,
+    };
+}
+function createEmptySummary(kind, destinationFolder, sourceFileCount) {
+    return {
+        title: kind === 'collection' ? 'Postman Collection Import' : 'Postman Environment Import',
+        kind,
+        sourceFileCount,
+        folderCount: 0,
+        requestCount: 0,
+        environmentCount: 0,
+        variableCount: 0,
+        secretCount: 0,
+        fileCount: 0,
+        destinationFolder,
+    };
+}
+function buildCollectionImport(sourceFilePath, destinationFolder, warnings, blockers) {
+    const root = readJsonObject(sourceFilePath, blockers);
+    if (!root) {
+        return undefined;
+    }
+    const info = asRecord(root.info);
+    const collectionTitle = asString(info?.name) || path.basename(sourceFilePath, '.json');
+    const schema = asString(info?.schema);
+    if (!schema || !schema.includes('collection')) {
+        blockers.push({
+            code: 'unsupported-schema',
+            message: 'Selected JSON does not look like a Postman Collection export.',
+            path: sourceFilePath,
+        });
+        return undefined;
+    }
+    if (!schema.includes('v2.1')) {
+        warnings.push({
+            code: 'schema-version',
+            message: `Collection schema is "${schema}". v1 targets Postman Collection v2.1 and may import partially.`,
+            sourcePath: sourceFilePath,
+        });
+    }
+    const itemList = asArray(root.item);
+    if (!itemList || itemList.length === 0) {
+        blockers.push({
+            code: 'empty-collection',
+            message: 'Collection has no items to import.',
+            path: sourceFilePath,
+        });
+        return undefined;
+    }
+    const collectionVariables = readPostmanVariables(root.variable);
+    const build = collectCollectionRequests(itemList, collectionTitle, warnings, sourceFilePath, asRecord(root.auth));
+    if (build.requests.length === 0) {
+        blockers.push({
+            code: 'no-requests',
+            message: 'No importable requests were found in the collection.',
+            path: sourceFilePath,
+        });
+        return undefined;
+    }
+    build.collectionVariables = collectionVariables;
+    const apiFileBase = `${toKebab(collectionTitle) || 'postman-collection'}.nornapi`;
+    const apiFileRelative = apiFileBase;
+    const apiFileAbsolute = path.join(destinationFolder, apiFileRelative);
+    const headerGroups = assignReusableHeaderGroups(build.requests);
+    const activeCollectionVariables = build.collectionVariables.filter(v => !v.disabled);
+    const files = [];
+    if (activeCollectionVariables.length > 0) {
+        const envRelative = '.nornenv';
+        const envAbsolute = path.join(destinationFolder, envRelative);
+        files.push({
+            relativePath: envRelative,
+            absolutePath: envAbsolute,
+            language: 'nornenv',
+            content: generateNornEnvContent([], activeCollectionVariables.map(variable => ({
+                key: variable.key,
+                value: variable.value,
+                secret: false,
+            })), 'Postman collection variables'),
+            existsCollision: fs.existsSync(envAbsolute),
+        });
+    }
+    files.push({
+        relativePath: normalizeRelativePath(apiFileRelative),
+        absolutePath: apiFileAbsolute,
+        language: 'nornapi',
+        content: generateNornApiContent(collectionTitle, build.requests, headerGroups),
+        existsCollision: fs.existsSync(apiFileAbsolute),
+    });
+    const requestsByFile = new Map();
+    for (const request of build.requests) {
+        const key = getFolderFileRelativePath(request.folderPath);
+        const list = requestsByFile.get(key) ?? [];
+        list.push(request);
+        requestsByFile.set(key, list);
+    }
+    const folderFiles = new Set();
+    for (const folder of build.folders) {
+        folderFiles.add(folder.fileRelativePath);
+    }
+    for (const fileRelative of requestsByFile.keys()) {
+        folderFiles.add(fileRelative);
+    }
+    const sortedNornFiles = Array.from(folderFiles).sort((a, b) => a.localeCompare(b));
+    for (const fileRelative of sortedNornFiles) {
+        const nornRequests = requestsByFile.get(fileRelative) ?? [];
+        const absolutePath = path.join(destinationFolder, fileRelative);
+        files.push({
+            relativePath: normalizeRelativePath(fileRelative),
+            absolutePath,
+            language: 'norn',
+            content: generateNornFileContent(fileRelative, apiFileRelative, nornRequests, headerGroups, warnings),
+            existsCollision: fs.existsSync(absolutePath),
+        });
+    }
+    return {
+        title: collectionTitle,
+        files,
+        folderCount: build.folders.length,
+        requestCount: build.requests.length,
+        variableCount: build.collectionVariables.filter(v => !v.disabled).length,
+    };
+}
+function buildEnvironmentImport(sourceFilePaths, destinationFolder, warnings, blockers) {
+    const sections = [];
+    const usedNames = new Set();
+    let variableCount = 0;
+    let secretCount = 0;
+    for (const sourceFilePath of sourceFilePaths) {
+        const root = readJsonObject(sourceFilePath, blockers);
+        if (!root) {
+            continue;
+        }
+        const schema = asString(root._postman_variable_scope) || asString(root._postman_exported_using);
+        const envNameRaw = asString(root.name) || path.basename(sourceFilePath, '.json');
+        const envName = sanitizeEnvName(envNameRaw);
+        if (!envName) {
+            blockers.push({
+                code: 'invalid-env-name',
+                message: `Could not derive a valid environment name from "${envNameRaw}".`,
+                path: sourceFilePath,
+            });
+            continue;
+        }
+        if (usedNames.has(envName)) {
+            blockers.push({
+                code: 'duplicate-env-name',
+                message: `Duplicate environment name after normalization: "${envName}".`,
+                path: sourceFilePath,
+            });
+            continue;
+        }
+        usedNames.add(envName);
+        if (schema && !String(schema).toLowerCase().includes('environment')) {
+            warnings.push({
+                code: 'environment-shape',
+                message: `File may not be a standard Postman Environment export (${schema}). Attempting import.`,
+                sourcePath: sourceFilePath,
+            });
+        }
+        const valuesArray = asArray(root.values);
+        if (!valuesArray) {
+            warnings.push({
+                code: 'env-values-missing',
+                message: `Environment "${envName}" has no values array.`,
+                sourcePath: sourceFilePath,
+            });
+            sections.push({ name: envName, variables: [] });
+            continue;
+        }
+        const variables = [];
+        for (const valueEntry of valuesArray) {
+            const entry = asRecord(valueEntry);
+            if (!entry) {
+                continue;
+            }
+            const key = asString(entry.key);
+            if (!key) {
+                continue;
+            }
+            const disabled = entry.enabled === false || entry.disabled === true;
+            if (disabled) {
+                warnings.push({
+                    code: 'disabled-env-var',
+                    message: `Skipped disabled environment value "${key}".`,
+                    sourcePath: sourceFilePath,
+                });
+                continue;
+            }
+            const value = stringifyScalar(entry.value);
+            const secret = SECRET_NAME_REGEX.test(key);
+            if (secret) {
+                secretCount += 1;
+            }
+            variableCount += 1;
+            variables.push({ key, value, secret });
+        }
+        sections.push({ name: envName, variables });
+    }
+    if (sections.length === 0) {
+        blockers.push({
+            code: 'no-env-sections',
+            message: 'No importable Postman environments were found in the selected JSON file(s).',
+        });
+        return undefined;
+    }
+    const envRelative = '.nornenv';
+    const envAbsolute = path.join(destinationFolder, envRelative);
+    const envFileExists = fs.existsSync(envAbsolute);
+    const existingEnvNames = envFileExists ? readExistingNornenvEnvironmentNames(envAbsolute) : new Set();
+    if (envFileExists) {
+        warnings.push({
+            code: 'nornenv-append-merge',
+            message: 'Destination already contains a .nornenv file. Imported environments will be appended; resolve conflicts manually if needed.',
+            sourcePath: envAbsolute,
+        });
+        for (const section of sections) {
+            if (existingEnvNames.has(section.name)) {
+                warnings.push({
+                    code: 'existing-env-name-conflict',
+                    message: `Environment "${section.name}" already exists in .nornenv and will be appended again.`,
+                    sourcePath: envAbsolute,
+                });
+            }
+        }
+    }
+    const file = {
+        relativePath: envRelative,
+        absolutePath: envAbsolute,
+        language: 'nornenv',
+        content: envFileExists ? generateNornEnvAppendContent(sections) : generateNornEnvContent(sections),
+        existsCollision: envFileExists,
+        writeMode: envFileExists ? 'append' : 'write',
+    };
+    const title = sections.length === 1 ? sections[0].name : `Postman Environments (${sections.length})`;
+    return {
+        title,
+        file,
+        environmentCount: sections.length,
+        variableCount,
+        secretCount,
+    };
+}
+function collectCollisionBlockers(files) {
+    return files
+        .filter(file => file.existsCollision && file.writeMode !== 'append')
+        .map(file => ({
+        code: 'file-overlap',
+        message: `Target file already exists: ${file.relativePath}`,
+        path: file.absolutePath,
+    }));
+}
+function readJsonObject(sourceFilePath, blockers) {
+    try {
+        const text = fs.readFileSync(sourceFilePath, 'utf8');
+        const parsed = JSON.parse(text);
+        const obj = asRecord(parsed);
+        if (!obj) {
+            blockers.push({
+                code: 'json-root-not-object',
+                message: 'JSON root is not an object.',
+                path: sourceFilePath,
+            });
+        }
+        return obj ?? undefined;
+    }
+    catch (error) {
+        blockers.push({
+            code: 'json-read-failed',
+            message: `Failed to read or parse JSON: ${error instanceof Error ? error.message : String(error)}`,
+            path: sourceFilePath,
+        });
+        return undefined;
+    }
+}
+function collectCollectionRequests(itemList, collectionTitle, warnings, sourcePath, collectionAuth) {
+    const folders = [];
+    const requests = [];
+    const endpointNames = new Set();
+    const requestNames = new Set();
+    const folderNameCounters = new Map();
+    const rootFolderAuth = collectionAuth;
+    function walk(items, folderPath, inheritedAuth) {
+        const siblingFolderCounts = new Map();
+        for (const itemUnknown of items) {
+            const item = asRecord(itemUnknown);
+            if (!item) {
+                continue;
+            }
+            const itemNameRaw = asString(item.name) || 'item';
+            const itemAuth = asRecord(item.auth);
+            const effectiveAuth = itemAuth ?? inheritedAuth;
+            const childItems = asArray(item.item);
+            if (childItems) {
+                const baseSegment = toKebab(itemNameRaw) || 'folder';
+                const dedupedSegment = dedupeSlug(baseSegment, siblingFolderCounts);
+                const nextPath = [...folderPath, dedupedSegment];
+                const fileRelativePath = getFolderFileRelativePath(nextPath);
+                folders.push({ pathSegments: nextPath, fileRelativePath });
+                walk(childItems, nextPath, effectiveAuth);
+                continue;
+            }
+            const requestValue = item.request;
+            const requestRecord = typeof requestValue === 'string' ? undefined : asRecord(requestValue);
+            const methodRaw = asString(requestRecord?.method) || 'GET';
+            const method = methodRaw.toUpperCase();
+            if (!SUPPORTED_METHODS.has(method)) {
+                warnings.push({
+                    code: 'unsupported-method',
+                    message: `Request "${itemNameRaw}" uses unsupported method "${methodRaw}". Skipped.`,
+                    sourcePath,
+                    requestName: itemNameRaw,
+                });
+                continue;
+            }
+            const urlRaw = buildRawUrl(requestRecord?.url);
+            if (!urlRaw) {
+                warnings.push({
+                    code: 'missing-url',
+                    message: `Request "${itemNameRaw}" has no URL. Skipped.`,
+                    sourcePath,
+                    requestName: itemNameRaw,
+                });
+                continue;
+            }
+            const requestWarnings = [];
+            const authHeadersAndUrl = resolveAuthToHeadersAndUrl(method, urlRaw, requestRecord?.auth, effectiveAuth, sourcePath, itemNameRaw);
+            requestWarnings.push(...authHeadersAndUrl.warnings);
+            const explicitHeaders = readHeaders(requestRecord?.header);
+            const mergedHeaders = mergeHeaders(explicitHeaders, authHeadersAndUrl.headers);
+            const body = renderRequestBody(requestRecord?.body, sourcePath, itemNameRaw);
+            requestWarnings.push(...body.warnings);
+            if (asArray(item.event)?.length) {
+                requestWarnings.push({
+                    code: 'postman-events-skipped',
+                    message: `Postman scripts/events on request "${itemNameRaw}" are not converted.`,
+                    sourcePath,
+                    requestName: itemNameRaw,
+                });
+            }
+            warnings.push(...requestWarnings);
+            const endpointName = dedupeIdentifier(toPascalIdentifier(itemNameRaw) || `${method}${toPascalIdentifier(collectionTitle) || 'Request'}`, endpointNames);
+            const namedRequestName = dedupeIdentifier(toPascalIdentifier(itemNameRaw) || `${endpointName}Request`, requestNames);
+            const endpointUrl = convertPostmanUrlToNornEndpoint(authHeadersAndUrl.url);
+            const endpointParamNames = extractEndpointParamNames(endpointUrl);
+            const endpointCall = endpointParamNames.length > 0
+                ? `${endpointName}(${endpointParamNames.map(name => `{{${name}}}`).join(', ')})`
+                : endpointName;
+            requests.push({
+                name: itemNameRaw,
+                endpointName,
+                namedRequestName,
+                folderPath,
+                method,
+                endpointUrl,
+                endpointCall,
+                inlineHeaders: mergedHeaders,
+                headerGroupSignature: mergedHeaders.length > 0 ? headerSignature(mergedHeaders) : undefined,
+                bodyText: body.bodyText,
+            });
+        }
+    }
+    // Fold top-level duplicate folder names deterministically across multiple passes if needed
+    void folderNameCounters;
+    walk(itemList, [], rootFolderAuth);
+    return {
+        title: collectionTitle,
+        folders,
+        requests,
+        collectionVariables: [],
+    };
+}
+function readPostmanVariables(value) {
+    const arr = asArray(value);
+    if (!arr) {
+        return [];
+    }
+    const result = [];
+    for (const entryUnknown of arr) {
+        const entry = asRecord(entryUnknown);
+        if (!entry) {
+            continue;
+        }
+        const key = asString(entry.key);
+        if (!key) {
+            continue;
+        }
+        const disabled = entry.enabled === false || entry.disabled === true;
+        result.push({
+            key,
+            value: stringifyScalar(entry.value),
+            disabled,
+        });
+    }
+    return result;
+}
+function buildRawUrl(urlValue) {
+    if (typeof urlValue === 'string') {
+        return urlValue.trim();
+    }
+    const url = asRecord(urlValue);
+    if (!url) {
+        return undefined;
+    }
+    const raw = asString(url.raw);
+    if (raw) {
+        return raw.trim();
+    }
+    const protocol = asString(url.protocol);
+    const host = buildHost(url.host);
+    const pathText = buildPath(url.path);
+    const queryText = buildQuery(url.query);
+    if (!host && !pathText) {
+        return undefined;
+    }
+    const protocolPrefix = protocol ? `${protocol}://` : '';
+    const base = `${protocolPrefix}${host || ''}${pathText}`;
+    return queryText ? `${base}${queryText}` : base;
+}
+function buildHost(hostValue) {
+    if (typeof hostValue === 'string') {
+        return hostValue;
+    }
+    const hostArr = asArray(hostValue);
+    if (!hostArr) {
+        return '';
+    }
+    const parts = hostArr.map(part => stringifyScalar(part)).filter(Boolean);
+    return parts.join('.');
+}
+function buildPath(pathValue) {
+    if (typeof pathValue === 'string') {
+        return pathValue.startsWith('/') ? pathValue : `/${pathValue}`;
+    }
+    const pathArr = asArray(pathValue);
+    if (!pathArr) {
+        return '';
+    }
+    const parts = pathArr.map(part => stringifyScalar(part)).filter(Boolean);
+    if (parts.length === 0) {
+        return '';
+    }
+    return `/${parts.join('/')}`;
+}
+function buildQuery(queryValue) {
+    const queryArr = asArray(queryValue);
+    if (!queryArr) {
+        return '';
+    }
+    const parts = [];
+    for (const itemUnknown of queryArr) {
+        const item = asRecord(itemUnknown);
+        if (!item) {
+            continue;
+        }
+        if (item.disabled === true) {
+            continue;
+        }
+        const key = asString(item.key);
+        if (!key) {
+            continue;
+        }
+        const value = asString(item.value);
+        parts.push(value !== undefined ? `${key}=${value}` : key);
+    }
+    return parts.length > 0 ? `?${parts.join('&')}` : '';
+}
+function resolveAuthToHeadersAndUrl(method, rawUrl, requestAuthValue, inheritedAuthValue, sourcePath, requestName) {
+    const warnings = [];
+    const headers = [];
+    let url = rawUrl;
+    const requestAuth = asRecord(requestAuthValue);
+    const inheritedAuth = asRecord(inheritedAuthValue);
+    const auth = requestAuth ?? inheritedAuth;
+    if (!auth) {
+        return { headers, url, warnings };
+    }
+    const type = asString(auth.type)?.toLowerCase();
+    if (!type || type === 'noauth') {
+        return { headers, url, warnings };
+    }
+    if (type === 'bearer') {
+        const attrs = readKeyValueMap(auth.bearer);
+        const token = attrs.get('token');
+        if (token) {
+            headers.push({ name: 'Authorization', value: `Bearer ${token}` });
+        }
+        else {
+            warnings.push({
+                code: 'auth-bearer-missing-token',
+                message: `Bearer auth on "${requestName}" is missing a token value.`,
+                sourcePath,
+                requestName,
+            });
+        }
+        return { headers, url, warnings };
+    }
+    if (type === 'basic') {
+        const attrs = readKeyValueMap(auth.basic);
+        const username = attrs.get('username') ?? '';
+        const password = attrs.get('password') ?? '';
+        const encoded = Buffer.from(`${username}:${password}`, 'utf8').toString('base64');
+        headers.push({ name: 'Authorization', value: `Basic ${encoded}` });
+        return { headers, url, warnings };
+    }
+    if (type === 'apikey') {
+        const attrs = readKeyValueMap(auth.apikey);
+        const key = attrs.get('key');
+        const value = attrs.get('value') ?? '';
+        const where = (attrs.get('in') ?? 'header').toLowerCase();
+        if (!key) {
+            warnings.push({
+                code: 'auth-apikey-missing-key',
+                message: `API Key auth on "${requestName}" is missing the key field.`,
+                sourcePath,
+                requestName,
+            });
+            return { headers, url, warnings };
+        }
+        if (where === 'header') {
+            headers.push({ name: key, value });
+        }
+        else if (where === 'query') {
+            url = appendQueryParam(url, key, value);
+        }
+        else {
+            warnings.push({
+                code: 'auth-apikey-unsupported-location',
+                message: `API Key auth location "${where}" on "${requestName}" is not supported. Header/query only in v1.`,
+                sourcePath,
+                requestName,
+            });
+        }
+        return { headers, url, warnings };
+    }
+    warnings.push({
+        code: 'unsupported-auth',
+        message: `Auth type "${type}" on "${requestName}" is not converted in v1.`,
+        sourcePath,
+        requestName,
+    });
+    void method;
+    return { headers, url, warnings };
+}
+function appendQueryParam(url, key, value) {
+    if (!key) {
+        return url;
+    }
+    const separator = url.includes('?') ? '&' : '?';
+    return `${url}${separator}${key}=${value}`;
+}
+function readKeyValueMap(value) {
+    const result = new Map();
+    const arr = asArray(value);
+    if (!arr) {
+        return result;
+    }
+    for (const itemUnknown of arr) {
+        const item = asRecord(itemUnknown);
+        if (!item) {
+            continue;
+        }
+        if (item.disabled === true) {
+            continue;
+        }
+        const key = asString(item.key);
+        if (!key) {
+            continue;
+        }
+        result.set(key.toLowerCase(), stringifyScalar(item.value));
+    }
+    return result;
+}
+function readHeaders(headerValue) {
+    const arr = asArray(headerValue);
+    if (!arr) {
+        return [];
+    }
+    const result = [];
+    for (const headerUnknown of arr) {
+        const header = asRecord(headerUnknown);
+        if (!header) {
+            continue;
+        }
+        if (header.disabled === true) {
+            continue;
+        }
+        const name = asString(header.key);
+        if (!name) {
+            continue;
+        }
+        result.push({ name, value: stringifyScalar(header.value) });
+    }
+    return result;
+}
+function mergeHeaders(explicitHeaders, authHeaders) {
+    const merged = [...explicitHeaders];
+    const lowerMap = new Map();
+    explicitHeaders.forEach((header, index) => lowerMap.set(header.name.toLowerCase(), index));
+    for (const header of authHeaders) {
+        const existingIndex = lowerMap.get(header.name.toLowerCase());
+        if (existingIndex !== undefined) {
+            merged[existingIndex] = header;
+        }
+        else {
+            lowerMap.set(header.name.toLowerCase(), merged.length);
+            merged.push(header);
+        }
+    }
+    return merged;
+}
+function renderRequestBody(bodyValue, sourcePath, requestName) {
+    const body = asRecord(bodyValue);
+    if (!body) {
+        return { warnings: [] };
+    }
+    const mode = asString(body.mode)?.toLowerCase();
+    if (!mode) {
+        return { warnings: [] };
+    }
+    if (mode === 'raw') {
+        const raw = asString(body.raw) ?? '';
+        if (!raw.trim()) {
+            return { warnings: [] };
+        }
+        const options = asRecord(body.options);
+        const rawOptions = asRecord(options?.raw);
+        const language = asString(rawOptions?.language)?.toLowerCase();
+        const looksJson = language === 'json' || isLikelyJson(raw);
+        if (!looksJson) {
+            return {
+                warnings: [{
+                        code: 'unsupported-body-raw',
+                        message: `Raw body on "${requestName}" is not JSON. v1 converts JSON and urlencoded only.`,
+                        sourcePath,
+                        requestName,
+                    }]
+            };
+        }
+        return { bodyText: raw, warnings: [] };
+    }
+    if (mode === 'urlencoded') {
+        const arr = asArray(body.urlencoded);
+        if (!arr) {
+            return { warnings: [] };
+        }
+        const lines = [];
+        for (const entryUnknown of arr) {
+            const entry = asRecord(entryUnknown);
+            if (!entry || entry.disabled === true) {
+                continue;
+            }
+            const key = asString(entry.key);
+            if (!key) {
+                continue;
+            }
+            const value = stringifyScalar(entry.value);
+            lines.push(`${key}=${value}`);
+        }
+        return { bodyText: lines.join('\n'), warnings: [] };
+    }
+    return {
+        warnings: [{
+                code: 'unsupported-body-mode',
+                message: `Body mode "${mode}" on "${requestName}" is not converted in v1 (JSON + urlencoded only).`,
+                sourcePath,
+                requestName,
+            }]
+    };
+}
+function isLikelyJson(value) {
+    const trimmed = value.trim();
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('['))) {
+        return false;
+    }
+    try {
+        JSON.parse(trimmed);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assignReusableHeaderGroups(requests) {
+    const signatureCounts = new Map();
+    const signatureHeaders = new Map();
+    for (const request of requests) {
+        const signature = request.headerGroupSignature;
+        if (!signature || request.inlineHeaders.length === 0) {
+            continue;
+        }
+        signatureCounts.set(signature, (signatureCounts.get(signature) ?? 0) + 1);
+        if (!signatureHeaders.has(signature)) {
+            signatureHeaders.set(signature, request.inlineHeaders);
+        }
+    }
+    const reusable = Array.from(signatureCounts.entries())
+        .filter(([, count]) => count >= 2)
+        .map(([signature]) => signature)
+        .sort((a, b) => a.localeCompare(b));
+    return reusable.map((signature, index) => ({
+        signature,
+        name: `Headers${String(index + 1).padStart(2, '0')}`,
+        headers: signatureHeaders.get(signature) ?? [],
+    }));
+}
+function generateNornApiContent(title, requests, headerGroups) {
+    const lines = [];
+    lines.push(`# Generated from Postman collection: ${title}`);
+    lines.push('# v1 import output - review and refine as needed');
+    lines.push('');
+    lines.push('endpoints');
+    for (const request of requests) {
+        lines.push(`    ${request.endpointName}: ${request.method} ${request.endpointUrl}`);
+    }
+    lines.push('end endpoints');
+    if (headerGroups.length > 0) {
+        lines.push('');
+        for (const group of headerGroups) {
+            lines.push('');
+            lines.push(`headers ${group.name}`);
+            for (const header of group.headers) {
+                lines.push(`${header.name}: ${header.value}`);
+            }
+            lines.push('end headers');
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function generateNornFileContent(fileRelativePath, apiFileRelativePath, requests, headerGroups, warnings) {
+    const lines = [];
+    const importPath = toRelativeImport(fileRelativePath, apiFileRelativePath);
+    lines.push(`import "${importPath}"`);
+    if (requests.length === 0) {
+        lines.push('');
+        lines.push('# Folder imported from Postman has no direct requests in this file (subfolders may exist).');
+        lines.push('');
+        return lines.join('\n');
+    }
+    const headerGroupBySignature = new Map(headerGroups.map(group => [group.signature, group.name]));
+    for (const request of requests) {
+        lines.push('');
+        lines.push(`[${request.namedRequestName}]`);
+        const headerGroupName = request.headerGroupSignature ? headerGroupBySignature.get(request.headerGroupSignature) : undefined;
+        lines.push(`${request.method} ${request.endpointCall}${headerGroupName ? ` ${headerGroupName}` : ''}`);
+        if (!headerGroupName) {
+            for (const header of request.inlineHeaders) {
+                lines.push(`${header.name}: ${header.value}`);
+            }
+        }
+        if (request.bodyText && request.bodyText.length > 0) {
+            lines.push('');
+            lines.push(request.bodyText);
+        }
+    }
+    void warnings;
+    lines.push('');
+    return lines.join('\n');
+}
+function generateNornEnvContent(sections, commonVariables = [], sourceLabel = 'Postman environment JSON') {
+    const lines = [];
+    lines.push(`# Generated from ${sourceLabel}`);
+    lines.push('# Review imported values and secrets before committing.');
+    if (commonVariables.length > 0) {
+        lines.push('');
+        for (const variable of commonVariables) {
+            const keyword = variable.secret ? 'secret' : 'var';
+            lines.push(`${keyword} ${sanitizeVariableName(variable.key)} = ${toNornLiteral(variable.value)}`);
+        }
+    }
+    for (const section of sections) {
+        lines.push('');
+        lines.push(`[env:${section.name}]`);
+        if (section.variables.length === 0) {
+            lines.push('# (no variables)');
+            continue;
+        }
+        for (const variable of section.variables) {
+            const keyword = variable.secret ? 'secret' : 'var';
+            lines.push(`${keyword} ${sanitizeVariableName(variable.key)} = ${toNornLiteral(variable.value)}`);
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function generateNornEnvAppendContent(sections) {
+    const lines = [];
+    lines.push('');
+    lines.push('# Appended from Postman environment JSON import');
+    for (const section of sections) {
+        lines.push('');
+        lines.push(`[env:${section.name}]`);
+        if (section.variables.length === 0) {
+            lines.push('# (no variables)');
+            continue;
+        }
+        for (const variable of section.variables) {
+            const keyword = variable.secret ? 'secret' : 'var';
+            lines.push(`${keyword} ${sanitizeVariableName(variable.key)} = ${toNornLiteral(variable.value)}`);
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function readExistingNornenvEnvironmentNames(filePath) {
+    const names = new Set();
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const regex = /^\[env:([a-zA-Z_][a-zA-Z0-9_-]*)\]$/gm;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            names.add(match[1]);
+        }
+    }
+    catch {
+        // Best effort only; import can still proceed in append mode.
+    }
+    return names;
+}
+function convertPostmanUrlToNornEndpoint(rawUrl) {
+    // Convert colon-style path params to Norn endpoint path params.
+    const colonConverted = rawUrl.replace(/\/:([A-Za-z_][A-Za-z0-9_-]*)/g, '/{$1}');
+    // Preserve a leading base URL variable (e.g. {{url}}, {{baseUrl}}) so it stays sourced from .nornenv,
+    // but convert placeholders in the remainder of the path/query into endpoint parameters.
+    const leadingBaseVarMatch = colonConverted.match(/^(\{\{[A-Za-z_][A-Za-z0-9_-]*\}\})(.*)$/);
+    if (leadingBaseVarMatch) {
+        return leadingBaseVarMatch[1] + convertPathAndQueryPlaceholdersToEndpointParams(leadingBaseVarMatch[2]);
+    }
+    // For full URLs, preserve placeholders inside the authority/host portion and only convert path/query placeholders.
+    const split = splitUrlAuthorityAndPath(colonConverted);
+    return split.prefix + convertPathAndQueryPlaceholdersToEndpointParams(split.suffix);
+}
+function extractEndpointParamNames(endpointUrl) {
+    const names = [];
+    const seen = new Set();
+    // Match single-brace endpoint params only. This must ignore Norn variable placeholders like {{baseUrl}}.
+    const regex = /(?<!\{)\{([A-Za-z_][A-Za-z0-9_-]*)\}(?!\})/g;
+    let match;
+    while ((match = regex.exec(endpointUrl)) !== null) {
+        const name = match[1];
+        if (!seen.has(name)) {
+            seen.add(name);
+            names.push(name);
+        }
+    }
+    return names;
+}
+function convertPathAndQueryPlaceholdersToEndpointParams(value) {
+    if (!value) {
+        return value;
+    }
+    return value.replace(/\{\{([A-Za-z_][A-Za-z0-9_-]*)\}\}/g, '{$1}');
+}
+function splitUrlAuthorityAndPath(url) {
+    const schemeIndex = url.indexOf('://');
+    if (schemeIndex < 0) {
+        return { prefix: '', suffix: url };
+    }
+    const authorityStart = schemeIndex + 3;
+    const slashIndex = url.indexOf('/', authorityStart);
+    const queryIndex = url.indexOf('?', authorityStart);
+    let splitIndex = -1;
+    if (slashIndex >= 0 && queryIndex >= 0) {
+        splitIndex = Math.min(slashIndex, queryIndex);
+    }
+    else if (slashIndex >= 0) {
+        splitIndex = slashIndex;
+    }
+    else if (queryIndex >= 0) {
+        splitIndex = queryIndex;
+    }
+    if (splitIndex < 0) {
+        return { prefix: url, suffix: '' };
+    }
+    return {
+        prefix: url.slice(0, splitIndex),
+        suffix: url.slice(splitIndex),
+    };
+}
+function headerSignature(headers) {
+    return headers
+        .map(header => `${header.name.toLowerCase()}:${header.value}`)
+        .sort((a, b) => a.localeCompare(b))
+        .join('\n');
+}
+function getFolderFileRelativePath(folderPath) {
+    if (folderPath.length === 0) {
+        return 'root.norn';
+    }
+    const parent = folderPath.slice(0, -1);
+    const fileName = `${folderPath[folderPath.length - 1]}.norn`;
+    return normalizeRelativePath(path.join(...parent, fileName));
+}
+function toRelativeImport(fromFileRelativePath, targetFileRelativePath) {
+    const fromDir = path.posix.dirname(toPosixPath(fromFileRelativePath));
+    const target = toPosixPath(targetFileRelativePath);
+    let relative = path.posix.relative(fromDir, target);
+    if (!relative.startsWith('.')) {
+        relative = `./${relative}`;
+    }
+    return relative;
+}
+function normalizeRelativePath(filePath) {
+    return toPosixPath(filePath);
+}
+function toPosixPath(filePath) {
+    return filePath.split(path.sep).join(path.posix.sep);
+}
+function sanitizeEnvName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return '';
+    }
+    let normalized = trimmed.replace(/\s+/g, '-').replace(/[^A-Za-z0-9_-]/g, '-');
+    normalized = normalized.replace(/-+/g, '-');
+    if (!/^[A-Za-z_]/.test(normalized)) {
+        normalized = `env-${normalized}`;
+    }
+    return normalized;
+}
+function sanitizeVariableName(name) {
+    let value = name.trim().replace(/[^A-Za-z0-9_]/g, '_');
+    value = value.replace(/_+/g, '_');
+    if (!value) {
+        value = 'value';
+    }
+    if (!/^[A-Za-z_]/.test(value)) {
+        value = `v_${value}`;
+    }
+    return value;
+}
+function toNornLiteral(value) {
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return value;
+    }
+    if (/^(true|false|null)$/i.test(value)) {
+        return value.toLowerCase();
+    }
+    if (/^https?:\/\/\S+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function toKebab(value) {
+    return value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+function toPascalIdentifier(value) {
+    const parts = value
+        .trim()
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .split(/\s+/)
+        .filter(Boolean);
+    let combined = parts
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    if (!combined) {
+        return '';
+    }
+    if (!/^[A-Za-z_]/.test(combined)) {
+        combined = `N${combined}`;
+    }
+    return combined;
+}
+function dedupeIdentifier(base, used) {
+    let candidate = base || 'GeneratedItem';
+    let counter = 2;
+    while (used.has(candidate)) {
+        candidate = `${base}${counter}`;
+        counter += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function dedupeSlug(base, siblingCounts) {
+    const count = (siblingCounts.get(base) ?? 0) + 1;
+    siblingCounts.set(base, count);
+    return count === 1 ? base : `${base}-${count}`;
+}
+function stringifyScalar(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return JSON.stringify(value);
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+//# sourceMappingURL=postmanImportPlanner.js.map