pomljs/dist/util/trace.js

Prompt Orchestration Markup Language

import { mkdirSync, writeSync, closeSync, writeFileSync, symlinkSync, openSync } from 'fs';
import path__default from 'path';

function replaceBuffers(value) {
    if (Buffer.isBuffer(value)) {
        const wrapper = { __base64__: value.toString('base64') };
        return wrapper;
    }
    else if (Array.isArray(value)) {
        return value.map(replaceBuffers);
    }
    else if (value && typeof value === 'object') {
        const result = {};
        for (const k of Object.keys(value)) {
            result[k] = replaceBuffers(value[k]);
        }
        return result;
    }
    return value;
}
function parseJsonWithBuffers(text) {
    return JSON.parse(text, (_key, value) => {
        if (value && typeof value === 'object' && value.__base64__) {
            return Buffer.from(value.__base64__, 'base64');
        }
        return value;
    });
}
let traceEnabled = false;
let traceDir;
function setTrace(enabled = true, dir) {
    traceEnabled = enabled;
    if (!enabled) {
        traceDir = undefined;
        return undefined;
    }
    const envDir = process.env.POML_TRACE;
    if (dir) {
        const base = path__default.resolve(dir);
        mkdirSync(base, { recursive: true });
        traceDir = base;
    }
    else if (envDir) {
        mkdirSync(envDir, { recursive: true });
        traceDir = envDir;
    }
    else {
        traceDir = undefined;
    }
    return traceDir;
}
function clearTrace() {
    traceEnabled = false;
    traceDir = undefined;
}
function isTracing() {
    return traceEnabled && !!traceDir;
}
function nextIndex(sourcePath) {
    if (!traceDir) {
        return [0, '', -1];
    }
    const fileName = sourcePath ? path__default.basename(sourcePath, '.poml') : '';
    for (let i = 1;; i++) {
        const idxStr = i.toString().padStart(4, '0');
        const prefix = path__default.join(traceDir, idxStr) + (fileName ? `.${fileName}` : '');
        const filePath = `${prefix}.poml`;
        try {
            const fd = openSync(filePath, 'wx');
            return [i, prefix, fd];
        }
        catch (err) {
            if (err.code === 'EEXIST') {
                continue;
            }
            throw err;
        }
    }
}
function dumpTrace(markup, context, stylesheet, result, sourcePath) {
    if (!isTracing()) {
        return;
    }
    const [_idx, prefix, fd] = nextIndex(sourcePath);
    try {
        writeSync(fd, markup);
    }
    finally {
        closeSync(fd);
    }
    if (sourcePath) {
        const envFile = `${prefix}.env`;
        writeFileSync(envFile, `SOURCE_PATH=${sourcePath}\n`);
        const linkPath = `${prefix}.source.poml`;
        try {
            symlinkSync(sourcePath, linkPath);
        }
        catch {
            console.warn(`Failed to create symlink for source path: ${sourcePath}`);
        }
    }
    if (context && Object.keys(context).length > 0) {
        writeFileSync(`${prefix}.context.json`, JSON.stringify(replaceBuffers(context), null, 2));
    }
    if (stylesheet && Object.keys(stylesheet).length > 0) {
        writeFileSync(`${prefix}.stylesheet.json`, JSON.stringify(replaceBuffers(stylesheet), null, 2));
    }
    if (result !== undefined) {
        writeFileSync(`${prefix}.result.json`, JSON.stringify(replaceBuffers(result), null, 2));
    }
}
if (process.env.POML_TRACE) {
    setTrace(true, process.env.POML_TRACE);
}

export { clearTrace, dumpTrace, isTracing, parseJsonWithBuffers, setTrace };
//# sourceMappingURL=trace.js.map