@mseep/bw-modeling-mcp 0.8.0

package/dist/tools/reporting.js

@@ -0,0 +1,558 @@
+const BICS_ACCEPT = 'application/vnd.sap.bw.modeling.bicsresponse-v1_1_0+xml';
+const BICS_CONTENT_TYPE = 'application/vnd.sap.bw.modeling.bicsrequest-v1_1_0+xml';
+const VALUE_HELP_ACCEPT = 'application/vnd.sap-bw-modeling.isvaluehelp-v1_0_0+xml';
+// ── XML helpers ────────────────────────────────────────────────────────────────
+function attr(s, name) {
+    const m = s.match(new RegExp(`\\b${name}="([^"]*)"`));
+    return m ? m[1] : null;
+}
+function xmlEscape(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function parseQueryViewAttrs(xml) {
+    const m = xml.match(/<queryView\b([\s\S]*?)>/);
+    const a = m?.[1] ?? '';
+    return {
+        name: attr(a, 'name'),
+        txt: attr(a, 'txt'),
+        dataRollup: attr(a, 'dataRollup'),
+    };
+}
+function parseMetaData(xml) {
+    const mdMatch = xml.match(/<metaData\b([\s\S]*?)>([\s\S]*?)<\/metaData>/);
+    if (!mdMatch)
+        return null;
+    const mdAttrs = mdMatch[1];
+    const mdBody = mdMatch[2];
+    const keyFigures = [];
+    const kfBlock = mdBody.match(/<keyFigures>([\s\S]*?)<\/keyFigures>/)?.[1] ?? '';
+    const entryRe = /<entry\b([\s\S]*?)(?:\/>|>)/g;
+    let em;
+    while ((em = entryRe.exec(kfBlock)) !== null) {
+        const a = em[1];
+        keyFigures.push({
+            name: attr(a, 'name') ?? '',
+            txt: attr(a, 'txt') ?? '',
+            id: attr(a, 'id') ?? '',
+            dataType: attr(a, 'dataType') ?? '',
+        });
+    }
+    const characteristics = [];
+    const chaBlock = mdBody.match(/<characteristics>([\s\S]*?)<\/characteristics>/)?.[1] ?? '';
+    entryRe.lastIndex = 0;
+    while ((em = entryRe.exec(chaBlock)) !== null) {
+        const a = em[1];
+        characteristics.push({
+            name: attr(a, 'name') ?? '',
+            txt: attr(a, 'txt') ?? '',
+            id: attr(a, 'id') ?? '',
+            axis: attr(a, 'axis') ?? '',
+            isStructure: attr(a, 'isStructure') ?? 'false',
+        });
+    }
+    return {
+        infoProvider: attr(mdAttrs, 'infoProvider'),
+        infoProviderText: attr(mdAttrs, 'infoProviderText'),
+        keyFigures,
+        characteristics,
+    };
+}
+function parseVariablesContainer(xml) {
+    const vcMatch = xml.match(/<variablesContainer\b([\s\S]*?)>([\s\S]*?)<\/variablesContainer>/);
+    if (!vcMatch)
+        return null;
+    const vcAttrs = vcMatch[1];
+    const vcBody = vcMatch[2];
+    const variables = [];
+    const varRe = /<variable\b([\s\S]*?)>([\s\S]*?)<\/variable>/g;
+    let vm;
+    while ((vm = varRe.exec(vcBody)) !== null) {
+        const vAttrs = vm[1];
+        const vBody = vm[2];
+        const selectValues = [];
+        const svRe = /<selectValue\b([\s\S]*?)(?:\/>|>)/g;
+        let sv;
+        while ((sv = svRe.exec(vBody)) !== null) {
+            const svA = sv[1];
+            const high = attr(svA, 'high');
+            const svObj = {
+                low: attr(svA, 'low') ?? '',
+                op: attr(svA, 'op') ?? '',
+                sign: attr(svA, 'sign') ?? '',
+                presentationMode: attr(svA, 'presentationMode') ?? '',
+            };
+            if (high !== null)
+                svObj.high = high;
+            selectValues.push(svObj);
+        }
+        variables.push({
+            id: attr(vAttrs, 'id') ?? '',
+            name: attr(vAttrs, 'name') ?? '',
+            altName: attr(vAttrs, 'altName') ?? '',
+            txt: attr(vAttrs, 'txt') ?? '',
+            iobj: attr(vAttrs, 'iobj') ?? '',
+            mandatory: attr(vAttrs, 'mandatory') ?? '',
+            inputEnabled: attr(vAttrs, 'inputEnabled') ?? '',
+            selectValues,
+        });
+    }
+    return {
+        size: attr(vcAttrs, 'size'),
+        inputRequired: attr(vcAttrs, 'inputRequired'),
+        variables,
+    };
+}
+function parseSpace(xml) {
+    const spaceMatch = xml.match(/<space>([\s\S]*?)<\/space>/);
+    if (!spaceMatch)
+        return [];
+    const result = [];
+    const ioRe = /<infoObject\b([\s\S]*?)>([\s\S]*?)<\/infoObject>/g;
+    let io;
+    while ((io = ioRe.exec(spaceMatch[1])) !== null) {
+        const ioAttrs = io[1];
+        const ioBody = io[2];
+        const selectValues = [];
+        const svRe = /<selectValue\b([\s\S]*?)(?:\/>|>)/g;
+        let sv;
+        while ((sv = svRe.exec(ioBody)) !== null) {
+            const svA = sv[1];
+            selectValues.push({
+                lowInt: attr(svA, 'lowInt') ?? attr(svA, 'low') ?? '',
+                op: attr(svA, 'op') ?? '',
+                sign: attr(svA, 'sign') ?? '',
+            });
+        }
+        result.push({
+            id: attr(ioAttrs, 'id') ?? '',
+            name: attr(ioAttrs, 'name') ?? '',
+            selectValues,
+        });
+    }
+    return result;
+}
+function parseTupleSection(sectionXml) {
+    const headersBlock = sectionXml.match(/<headers>([\s\S]*?)<\/headers>/)?.[1] ?? '';
+    const headers = [];
+    const hRe = /<entry\b([\s\S]*?)(?:\/>|>)/g;
+    let hm;
+    while ((hm = hRe.exec(headersBlock)) !== null) {
+        const ha = hm[1];
+        headers.push({ name: attr(ha, 'name') ?? '', txt: attr(ha, 'txt') ?? '', id: attr(ha, 'id') ?? '' });
+    }
+    const tuplesBlock = sectionXml.match(/<tuples\b[^>]*>([\s\S]*?)<\/tuples>/)?.[1] ?? '';
+    const tuples = [];
+    const tRe = /<tuple\b([\s\S]*?)>([\s\S]*?)<\/tuple>/g;
+    let tm;
+    while ((tm = tRe.exec(tuplesBlock)) !== null) {
+        const tAttrs = tm[1];
+        const tBody = tm[2];
+        const values = [];
+        const vRe = /<value\b([\s\S]*?)(?:\/>|>)/g;
+        let vm;
+        while ((vm = vRe.exec(tBody)) !== null) {
+            const va = vm[1];
+            const v = {
+                id: attr(va, 'id') ?? '',
+                sid: attr(va, 'sid') ?? '',
+                selType: attr(va, 'selType') ?? '',
+                extKey: attr(va, 'extKey') ?? '',
+                intKey: attr(va, 'intKey') ?? '',
+                txt: attr(va, 'txt') ?? '',
+            };
+            const drillSt = attr(va, 'drillSt');
+            const dispLvl = attr(va, 'dispLvl');
+            if (drillSt !== null)
+                v.drillSt = drillSt;
+            if (dispLvl !== null)
+                v.dispLvl = dispLvl;
+            values.push(v);
+        }
+        tuples.push({ tid: attr(tAttrs, 'tid') ?? '', values });
+    }
+    return { headers, tuples };
+}
+function parseResultSet(xml) {
+    if (/<resultSet\s*\/>/.test(xml)) {
+        return {
+            fromRow: '0',
+            toRow: '1000',
+            columnHeaders: [],
+            columnTuples: [],
+            rowHeaders: [],
+            rowTuples: [],
+            cells: [],
+        };
+    }
+    const rsMatch = xml.match(/<resultSet\b([\s\S]*?)>([\s\S]*?)<\/resultSet>/);
+    const rsAttrs = rsMatch?.[1] ?? '';
+    const rsBody = rsMatch?.[2] ?? '';
+    const columnsMatch = rsBody.match(/<columns\b[^>]*>([\s\S]*?)<\/columns>/);
+    const rowsMatch = rsBody.match(/<rows\b[^>]*>([\s\S]*?)<\/rows>/);
+    const colParsed = columnsMatch ? parseTupleSection(columnsMatch[1]) : { headers: [], tuples: [] };
+    const rowParsed = rowsMatch ? parseTupleSection(rowsMatch[1]) : { headers: [], tuples: [] };
+    const cells = [];
+    const dataBlock = rsBody.match(/<data\b[^>]*>([\s\S]*?)<\/data>/)?.[1] ?? '';
+    const cellRe = /<cell\b([\s\S]*?)(?:\/>|>)/g;
+    let cm;
+    while ((cm = cellRe.exec(dataBlock)) !== null) {
+        const ca = cm[1];
+        cells.push({
+            crv: attr(ca, 'crv') ?? '',
+            txt: attr(ca, 'txt') ?? '',
+            row: attr(ca, 'row') ?? '',
+            col: attr(ca, 'col') ?? '',
+            mcu: attr(ca, 'mcu') === 'true',
+        });
+    }
+    return {
+        fromRow: attr(rsAttrs, 'fromRow') ?? '0',
+        toRow: attr(rsAttrs, 'toRow') ?? '1000',
+        columnHeaders: colParsed.headers,
+        columnTuples: colParsed.tuples,
+        rowHeaders: rowParsed.headers,
+        rowTuples: rowParsed.tuples,
+        cells,
+    };
+}
+function parseMessages(xml) {
+    const msgMatch = xml.match(/<messages>([\s\S]*?)<\/messages>/);
+    if (!msgMatch)
+        return [];
+    const msgs = [];
+    const eRe = /<entry\b([\s\S]*?)(?:\/>|>)/g;
+    let em;
+    while ((em = eRe.exec(msgMatch[1])) !== null) {
+        const ea = em[1];
+        msgs.push({ type: attr(ea, 'type') ?? '', txt: attr(ea, 'txt') ?? '' });
+    }
+    return msgs;
+}
+// ── Text rendering ──────────────────────────────────────────────────────────────
+// Renders a human-readable label for a tuple's values.
+// Handles: normal members, hierarchy nodes (negative sid), TOTAL rows,
+// structure members (selType STRU1/STRU2 — identical rendering for both),
+// and REST_H (not assigned) nodes.
+// When a tuple has multiple values (multi-dimension drilldown), labels are
+// joined with ' / '.
+function tupleLabel(values) {
+    return values.map(v => {
+        if (v.selType === 'TOTAL' || v.intKey === 'SUMME')
+            return 'Total';
+        if (v.intKey === 'REST_H')
+            return '(not assigned)';
+        const sid = parseInt(v.sid, 10);
+        const label = v.txt || v.extKey || v.intKey;
+        if (sid < 0) {
+            const lvl = parseInt(v.dispLvl ?? '0', 10);
+            const indent = '  '.repeat(lvl);
+            const prefix = v.drillSt === '3' ? '+' : '+--';
+            return `${indent}${prefix} ${label}`;
+        }
+        if ((v.selType === 'STRU1' || v.selType === 'STRU2') && v.dispLvl !== undefined) {
+            const lvl = parseInt(v.dispLvl, 10);
+            const indent = '  '.repeat(lvl);
+            const prefix = v.drillSt === '3' ? 'v ' : v.drillSt === '2' ? '> ' : '';
+            return `${indent}${prefix}${label}`;
+        }
+        return label;
+    }).filter(s => s).join(' / ');
+}
+function renderQueryDataText(xml, isGet) {
+    const lines = [];
+    // 1. Header
+    const viewAttrs = parseQueryViewAttrs(xml);
+    lines.push(`Query/Provider: ${viewAttrs.name ?? ''}`);
+    if (viewAttrs.txt)
+        lines.push(`Description: ${viewAttrs.txt}`);
+    const metaData = isGet ? parseMetaData(xml) : null;
+    if (metaData) {
+        lines.push(`InfoProvider: ${metaData.infoProvider ?? ''}${metaData.infoProviderText ? ` (${metaData.infoProviderText})` : ''}`);
+    }
+    if (viewAttrs.dataRollup)
+        lines.push(`Data as of: ${viewAttrs.dataRollup}`);
+    const rs = parseResultSet(xml);
+    lines.push(`Row range: ${rs.fromRow}–${rs.toRow}`);
+    // 2. Variables
+    const vc = parseVariablesContainer(xml);
+    if (vc && vc.variables.length > 0) {
+        lines.push('');
+        lines.push(`── Variables (inputRequired=${vc.inputRequired}) ──`);
+        const allEmpty = vc.variables.every(v => v.selectValues.length === 0);
+        if (vc.inputRequired === 'true' && allEmpty) {
+            lines.push('  NOTE: Input required — fill variables via POST before data is available.');
+            lines.push('        Use bw_get_filter_values to look up valid characteristic values.');
+        }
+        for (const v of vc.variables) {
+            const req = v.mandatory === 'true' ? ' [REQUIRED]' : '';
+            const vals = v.selectValues.length > 0
+                ? v.selectValues
+                    .map(sv => `${sv.sign}${sv.op} ${sv.low}${sv.high ? `..${sv.high}` : ''}`)
+                    .join(', ')
+                : '(not set)';
+            lines.push(`  ${v.name.trimEnd()} (${v.txt})${req}: ${vals}`);
+        }
+    }
+    // 3. Background filters from <space>
+    const spaceFilters = parseSpace(xml);
+    if (spaceFilters.length > 0) {
+        lines.push('');
+        lines.push('── Background Filters (query-defined, read-only) ──');
+        for (const f of spaceFilters) {
+            const vals = f.selectValues.map(sv => `${sv.sign}${sv.op} ${sv.lowInt}`).join(', ');
+            lines.push(`  ${f.name}: ${vals}`);
+        }
+    }
+    // 4. Result table
+    lines.push('');
+    lines.push(`── Result (${rs.rowTuples.length} rows × ${rs.columnTuples.length} columns) ──`);
+    if (rs.columnTuples.length === 0 && rs.rowTuples.length === 0) {
+        lines.push('  (no data)');
+    }
+    else {
+        const cellMap = new Map();
+        for (const c of rs.cells) {
+            cellMap.set(`${c.row}:${c.col}`, { txt: c.txt, mcu: c.mcu });
+        }
+        const colLabels = rs.columnTuples.map(ct => tupleLabel(ct.values));
+        const rowAxisLabels = rs.rowHeaders.map(h => h.txt || h.name);
+        lines.push([...rowAxisLabels, ...colLabels].join(' | '));
+        lines.push('-'.repeat(Math.min(200, [...rowAxisLabels, ...colLabels].join(' | ').length)));
+        for (let ri = 0; ri < rs.rowTuples.length; ri++) {
+            const rt = rs.rowTuples[ri];
+            const rowIdx = ri + 1;
+            const isTotal = rt.values.some(v => v.selType === 'TOTAL' || v.intKey === 'SUMME');
+            if (isTotal)
+                lines.push('');
+            const rowLabel = tupleLabel(rt.values);
+            const cellValues = rs.columnTuples.map((_, ci) => {
+                const cell = cellMap.get(`${rowIdx}:${ci + 1}`);
+                if (!cell)
+                    return '-';
+                return cell.mcu ? '* (multi-currency)' : cell.txt;
+            });
+            lines.push([rowLabel, ...cellValues].join(' | '));
+        }
+    }
+    // 5. Messages
+    const msgs = parseMessages(xml);
+    if (msgs.length > 0) {
+        lines.push('');
+        lines.push('── Messages ──');
+        for (const m of msgs) {
+            lines.push(`  [${m.type}] ${m.txt}`);
+        }
+    }
+    // 6. Metadata (GET only)
+    if (isGet && metaData) {
+        if (metaData.keyFigures.length > 0) {
+            lines.push('');
+            lines.push('── Available Key Figures ──');
+            for (const kf of metaData.keyFigures) {
+                lines.push(`  ${kf.name} (${kf.txt}) [${kf.dataType}] id=${kf.id}`);
+            }
+        }
+        if (metaData.characteristics.length > 0) {
+            lines.push('');
+            lines.push('── Available Characteristics ──');
+            for (const cha of metaData.characteristics) {
+                const struct = cha.isStructure === 'true' ? ' [structure]' : '';
+                lines.push(`  ${cha.name} (${cha.txt}) axis=${cha.axis}${struct} id=${cha.id}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+// ── POST body builder ──────────────────────────────────────────────────────────
+function buildPostBody(compId, state, variables, drillOperations) {
+    const parts = [];
+    parts.push(`<?xml version="1.0" encoding="UTF-8"?>`);
+    parts.push(`<querySelector name="${xmlEscape(compId)}">`);
+    parts.push(`  <selection>`);
+    if (variables && variables.length > 0) {
+        parts.push(`    <variablesContainer>`);
+        for (const v of variables) {
+            const txt = v.txt ? ` txt="${xmlEscape(v.txt)}"` : '';
+            const altName = v.altName ? ` altName="${xmlEscape(v.altName)}"` : '';
+            const type = ` type="${xmlEscape(v.type ?? 'charMember')}"`;
+            const inputEnabled = ` inputEnabled="${v.inputEnabled !== undefined ? v.inputEnabled : true}"`;
+            const mandatory = v.mandatory !== undefined ? ` mandatory="${v.mandatory}"` : '';
+            const iobj = v.iobj ? ` iobj="${xmlEscape(v.iobj)}"` : '';
+            parts.push(`      <variable name="${xmlEscape(v.name)}" id="${xmlEscape(v.id)}"${txt}${altName}${type}${inputEnabled}${mandatory}${iobj}>`);
+            let svId = 0;
+            for (const sv of v.values) {
+                const op = sv.op ?? 'EQ';
+                const sign = sv.sign ?? 'I';
+                const high = sv.high ? ` high="${xmlEscape(sv.high)}"` : '';
+                parts.push(`        <selectValue id="${svId++}" low="${xmlEscape(sv.low)}"${high} nodeId="0" hryMinLvl="0" op="${op}" sign="${sign}" presentationMode="EXT"/>`);
+            }
+            parts.push(`      </variable>`);
+        }
+        parts.push(`    </variablesContainer>`);
+    }
+    if (state && state.infoObjects.length > 0) {
+        parts.push(`    <state>`);
+        for (const io of state.infoObjects) {
+            const hasFilter = io.filterValues && io.filterValues.length > 0;
+            if (hasFilter || io.hierarchy) {
+                parts.push(`      <infoObject name="${xmlEscape(io.name)}" id="${xmlEscape(io.id)}" axis="${xmlEscape(io.axis)}" pos="0">`);
+                if (io.hierarchy) {
+                    const hFrom = io.hierarchy.hryDateFrom ?? '00000000';
+                    const hTo = io.hierarchy.hryDateTo ?? '99991231';
+                    parts.push(`        <hierarchy id="${xmlEscape(io.hierarchy.id)}" name="${xmlEscape(io.hierarchy.name)}" hryId="${xmlEscape(io.hierarchy.hryId)}" hryDateFrom="${hFrom}" hryDateTo="${hTo}"/>`);
+                }
+                let svId = 0;
+                for (const fv of (io.filterValues ?? [])) {
+                    const op = fv.op ?? 'EQ';
+                    const sign = fv.sign ?? 'I';
+                    const lowText = fv.lowText ? ` lowText="${xmlEscape(fv.lowText)}"` : '';
+                    const high = fv.high ? ` high="${xmlEscape(fv.high)}"` : '';
+                    const nodeId = fv.nodeId ?? 0;
+                    if (fv.lowInt) {
+                        parts.push(`        <selectValue id="${svId++}" lowInt="${xmlEscape(fv.lowInt)}"${high} nodeId="${nodeId}" hryMinLvl="0" op="${op}" sign="${sign}" presentationMode="INT"/>`);
+                    }
+                    else {
+                        parts.push(`        <selectValue id="${svId++}" low="${xmlEscape(fv.low ?? '')}"${lowText}${high} nodeId="${nodeId}" hryMinLvl="0" op="${op}" sign="${sign}" presentationMode="EXT_NC"/>`);
+                    }
+                }
+                parts.push(`      </infoObject>`);
+            }
+            else {
+                parts.push(`      <infoObject name="${xmlEscape(io.name)}" id="${xmlEscape(io.id)}" axis="${xmlEscape(io.axis)}" pos="0"/>`);
+            }
+        }
+        parts.push(`    </state>`);
+    }
+    if (drillOperations && drillOperations.length > 0) {
+        parts.push(`    <drillOps>`);
+        drillOperations.forEach((op, i) => {
+            parts.push(`      <operation step="${i + 1}" axis="${op.axis}" drillSt="${op.drill_state}" ` +
+                `drillLvl="1" tupleIdx="${op.tuple_idx}" elementIdx="${op.element_idx}"/>`);
+        });
+        parts.push(`    </drillOps>`);
+    }
+    parts.push(`  </selection>`);
+    parts.push(`</querySelector>`);
+    return parts.join('\n');
+}
+// ── Exported functions ─────────────────────────────────────────────────────────
+export async function bwQueryData(client, compId, isProvider = false, format = 'text', state, variables, fromRow = 0, toRow = 1000, drillOperations) {
+    const effectiveCompId = isProvider ? `!${compId}` : compId;
+    const url = `/sap/bw/modeling/comp/reporting?compid=${encodeURIComponent(effectiveCompId)}`;
+    const isPost = !!(state || variables || (drillOperations && drillOperations.length > 0));
+    let responseXml;
+    if (isPost) {
+        const postBody = buildPostBody(compId, state, variables, drillOperations);
+        const doPost = async () => {
+            const csrfToken = await client.getCsrfToken();
+            const postResult = await client.rawPost(url, postBody, {
+                'Content-Type': BICS_CONTENT_TYPE,
+                'X-CSRF-Token': csrfToken,
+                Accept: BICS_ACCEPT,
+                InclMetadata: 'false',
+                InclExceptDef: 'true',
+                InclObjectValues: 'true',
+                HryLvlAbsRs: 'false',
+                FromRow: String(fromRow),
+                ToRow: String(toRow),
+                'X-sap-adt-sessiontype': 'stateless',
+            });
+            return postResult.body;
+        };
+        try {
+            responseXml = await doPost();
+        }
+        catch (err) {
+            // SAP returns HTTP 403 when the CSRF token has expired (session idle timeout).
+            // Retry once with a fresh token.
+            if (/csrf|403/i.test(String(err))) {
+                client.clearCsrfToken();
+                responseXml = await doPost();
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    else {
+        const { body } = await client.rawGet(url, {
+            Accept: BICS_ACCEPT,
+            InclMetadata: 'true',
+            InclExceptDef: 'true',
+            InclObjectValues: 'true',
+            CompactMode: 'false',
+            HryLvlAbsRs: 'false',
+            FromRow: String(fromRow),
+            ToRow: String(toRow),
+            'X-sap-adt-sessiontype': 'stateless',
+        });
+        responseXml = body;
+    }
+    if (format === 'raw')
+        return responseXml;
+    return renderQueryDataText(responseXml, !isPost);
+}
+export async function bwGetFilterValues(client, characteristicName, searchString, infoProvider, maxRows = 201) {
+    let url = `/sap/bw/modeling/is/values/characteristicvalues` +
+        `?characteristicname=${encodeURIComponent(characteristicName)}` +
+        `&maxrows=${maxRows}` +
+        `&readtexts=x` +
+        `&searchstring=${encodeURIComponent(searchString)}`;
+    if (infoProvider) {
+        url += `&infoprovider=${encodeURIComponent(infoProvider)}&readmode=d`;
+    }
+    const { body } = await client.rawGet(url, { Accept: VALUE_HELP_ACCEPT, 'X-sap-adt-sessiontype': 'stateless' });
+    // Parse metadata
+    const metaAttrs = body.match(/<valueHelpMetaInformation\b([^>]*?)(?:\/>|>)/)?.[1] ?? '';
+    const totalCount = attr(metaAttrs, 'valueHelpLines') ?? '';
+    const refChar = attr(metaAttrs, 'referenceCharacteristic') ?? characteristicName;
+    // Parse column names
+    const colNames = [];
+    const colRe = /<columnname>([^<]*)<\/columnname>/g;
+    let cm;
+    while ((cm = colRe.exec(body)) !== null) {
+        colNames.push(cm[1].trim());
+    }
+    // Parse rows
+    const rows = [];
+    const rowRe = /<row>([\s\S]*?)<\/row>/g;
+    let rm;
+    while ((rm = rowRe.exec(body)) !== null) {
+        const vals = [];
+        const valRe = /<value>([^<]*)<\/value>/g;
+        let vm;
+        while ((vm = valRe.exec(rm[1])) !== null) {
+            vals.push(vm[1]);
+        }
+        rows.push(vals);
+    }
+    const lines = [];
+    lines.push(`Characteristic: ${refChar}`);
+    lines.push(`Search: "${searchString}"${infoProvider ? ` | Provider: ${infoProvider}` : ''}`);
+    lines.push(`Results: ${rows.length}${totalCount ? ` of ${totalCount}` : ''}`);
+    lines.push('');
+    lines.push('NOTE: Use CHAVL_EXT for state filters (presentationMode="EXT"). Use CHAVL_INT for variable inputs. When CHAVL_EXT and CHAVL_INT are identical, either works.');
+    lines.push('');
+    if (rows.length === 0) {
+        lines.push('(no values returned)');
+        return lines.join('\n');
+    }
+    // Column widths
+    const widths = colNames.map(n => n.length);
+    for (const row of rows) {
+        for (let i = 0; i < row.length; i++) {
+            widths[i] = Math.max(widths[i] ?? 0, (row[i] ?? '').length);
+        }
+    }
+    const pad = (s, w) => s.padEnd(w);
+    lines.push(colNames.map((n, i) => pad(n, widths[i])).join('  '));
+    lines.push(widths.map(w => '-'.repeat(w)).join('  '));
+    for (const row of rows) {
+        lines.push(row.map((v, i) => pad(v, widths[i] ?? 0)).join('  '));
+    }
+    return lines.join('\n');
+}

package/dist/tools/repository.js

@@ -0,0 +1,84 @@
+const BASE = '/sap/bw/modeling/repo/infoproviderstructure';
+const CHILDREN_PREFIX = `${BASE}/`;
+function parseAtomFeed(xml) {
+    const entries = [];
+    const entryRegex = /<atom:entry\b[^>]*>([\s\S]*?)<\/atom:entry>/g;
+    let em;
+    while ((em = entryRegex.exec(xml)) !== null) {
+        const body = em[1];
+        // bwModel:object attributes (may be self-closing or open)
+        const bwObjMatch = body.match(/<bwModel:object\b([\s\S]*?)(?:\/>|>)/);
+        const bwAttrs = bwObjMatch?.[1] ?? '';
+        const objectName = bwAttrs.match(/\bobjectName="([^"]*)"/)?.[1] ?? '';
+        const objectType = bwAttrs.match(/\bobjectType="([^"]*)"/)?.[1] ?? '';
+        const objectStatusRaw = bwAttrs.match(/\bobjectStatus="([^"]*)"/)?.[1];
+        const objectSubtypeRaw = bwAttrs.match(/\bobjectSubtype="([^"]*)"/)?.[1];
+        const objectStatus = objectStatusRaw !== undefined ? objectStatusRaw : null;
+        const objectSubtype = objectSubtypeRaw !== undefined ? objectSubtypeRaw : null;
+        // atom:title
+        const title = body.match(/<atom:title[^>]*>([^<]*)<\/atom:title>/)?.[1] ?? '';
+        // atom:link elements
+        let selfHref = null;
+        let selfLinkType = null;
+        let childrenHref = null;
+        const linkRegex = /<atom:link\b([\s\S]*?)(?:\/>|>)/g;
+        let lm;
+        while ((lm = linkRegex.exec(body)) !== null) {
+            const attrs = lm[1];
+            const rel = attrs.match(/\brel="([^"]*)"/)?.[1] ?? '';
+            const href = attrs.match(/\bhref="([^"]*)"/)?.[1] ?? '';
+            const type = attrs.match(/\btype="([^"]*)"/)?.[1] ?? '';
+            if (rel === 'self') {
+                selfHref = href || null;
+                selfLinkType = type || null;
+            }
+            else if (rel === 'http://www.sap.com/bw/modeling/relations:children') {
+                childrenHref = href || null;
+            }
+        }
+        // Fiori URL detection (RSPC and similar objects with no REST endpoint)
+        const fioriOnly = selfLinkType === 'application/vnd.sap-bw-modeling.url' ||
+            (selfHref !== null && selfHref.includes('#BWProcessChain'));
+        // Chain ID (RSPC objects only)
+        let chainId;
+        if (fioriOnly && selfHref) {
+            const match = selfHref.match(/[?&]chainId=([^&#]+)/);
+            if (match)
+                chainId = decodeURIComponent(match[1]);
+        }
+        // children_path: strip the base prefix to give a path usable with this tool
+        let childrenPath = null;
+        if (childrenHref) {
+            childrenPath = childrenHref.startsWith(CHILDREN_PREFIX)
+                ? childrenHref.slice(CHILDREN_PREFIX.length)
+                : childrenHref;
+        }
+        const entry = {
+            name: objectName,
+            description: title,
+            object_type: objectType,
+            object_subtype: objectSubtype,
+            status: objectStatus,
+            has_children: childrenHref !== null,
+            self_url: selfHref,
+            fiori_only: fioriOnly,
+            children_path: childrenPath,
+        };
+        if (chainId !== undefined)
+            entry.chain_id = chainId;
+        entries.push(entry);
+    }
+    return entries;
+}
+export async function bwListContents(client, path) {
+    // Normalise: strip leading/trailing slashes, lowercase
+    const normalizedPath = path.toLowerCase().replace(/^\/+/, '').replace(/\/+$/, '');
+    const url = normalizedPath ? `${BASE}/${normalizedPath}` : BASE;
+    const { body } = await client.get(url, 'application/atom+xml');
+    const entries = parseAtomFeed(body);
+    return JSON.stringify({
+        path: path || '/',
+        count: entries.length,
+        entries,
+    }, null, 2);
+}