@ifc-lite/cli 0.2.0 → 0.4.0

package/dist/commands/query.js

@@ -10,6 +10,86 @@
  */
 import { createHeadlessContext } from '../loader.js';
 import { printJson, formatTable, getFlag, hasFlag, fatal } from '../output.js';
+/**
+ * Standard IFC quantity set definitions — maps entity type to its standard Qto_ sets
+ * and the quantities within each set. Used for disambiguation warnings.
+ */
+const STANDARD_QTO_MAP = {
+    IfcWall: {
+        Qto_WallBaseQuantities: ['Length', 'Width', 'Height', 'GrossFootprintArea', 'NetFootprintArea', 'GrossSideArea', 'NetSideArea', 'GrossVolume', 'NetVolume'],
+    },
+    IfcSlab: {
+        Qto_SlabBaseQuantities: ['Width', 'Length', 'Depth', 'Perimeter', 'GrossArea', 'NetArea', 'GrossVolume', 'NetVolume'],
+    },
+    IfcDoor: {
+        Qto_DoorBaseQuantities: ['Width', 'Height', 'Perimeter', 'Area'],
+    },
+    IfcWindow: {
+        Qto_WindowBaseQuantities: ['Width', 'Height', 'Perimeter', 'Area'],
+    },
+    IfcColumn: {
+        Qto_ColumnBaseQuantities: ['Length', 'CrossSectionArea', 'OuterSurfaceArea', 'GrossSurfaceArea', 'NetSurfaceArea', 'GrossVolume', 'NetVolume', 'GrossWeight', 'NetWeight'],
+    },
+    IfcBeam: {
+        Qto_BeamBaseQuantities: ['Length', 'CrossSectionArea', 'OuterSurfaceArea', 'GrossSurfaceArea', 'NetSurfaceArea', 'GrossVolume', 'NetVolume', 'GrossWeight', 'NetWeight'],
+    },
+    IfcSpace: {
+        Qto_SpaceBaseQuantities: ['Height', 'FinishCeilingHeight', 'FinishFloorHeight', 'GrossPerimeter', 'NetPerimeter', 'GrossFloorArea', 'NetFloorArea', 'GrossWallArea', 'NetWallArea', 'GrossCeilingArea', 'NetCeilingArea', 'GrossVolume', 'NetVolume'],
+    },
+    IfcRoof: {
+        Qto_RoofBaseQuantities: ['GrossArea', 'NetArea', 'ProjectedArea'],
+    },
+    IfcStair: {
+        Qto_StairBaseQuantities: ['Length', 'GrossVolume', 'NetVolume'],
+    },
+    IfcRailing: {
+        Qto_RailingBaseQuantities: ['Length'],
+    },
+    IfcMember: {
+        Qto_MemberBaseQuantities: ['Length', 'CrossSectionArea', 'OuterSurfaceArea', 'GrossSurfaceArea', 'NetSurfaceArea', 'GrossVolume', 'NetVolume', 'GrossWeight', 'NetWeight'],
+    },
+    IfcPlate: {
+        Qto_PlateBaseQuantities: ['Width', 'Length', 'Perimeter', 'GrossArea', 'NetArea', 'GrossVolume', 'NetVolume', 'GrossWeight', 'NetWeight'],
+    },
+    IfcCovering: {
+        Qto_CoveringBaseQuantities: ['Width', 'Length', 'GrossArea', 'NetArea'],
+    },
+    IfcFooting: {
+        Qto_FootingBaseQuantities: ['Length', 'Width', 'Height', 'CrossSectionArea', 'OuterSurfaceArea', 'GrossVolume', 'NetVolume', 'GrossWeight', 'NetWeight'],
+    },
+};
+/**
+ * Parse a --where filter string into psetName, propName, operator, value.
+ * Supported formats:
+ *   PsetName.PropName=Value     (equals)
+ *   PsetName.PropName!=Value    (not equals)
+ *   PsetName.PropName>Value     (greater than)
+ *   PsetName.PropName<Value     (less than)
+ *   PsetName.PropName>=Value    (greater or equal)
+ *   PsetName.PropName<=Value    (less or equal)
+ *   PsetName.PropName~Value     (contains)
+ *   PsetName.PropName           (exists)
+ */
+function parseWhereFilter(filter) {
+    const dotIdx = filter.indexOf('.');
+    if (dotIdx <= 0) {
+        fatal(`Invalid --where syntax: "${filter}". Expected: PsetName.PropName[=Value]`);
+    }
+    const psetName = filter.slice(0, dotIdx);
+    const rest = filter.slice(dotIdx + 1);
+    // Try multi-char operators first, then single-char
+    for (const op of ['!=', '>=', '<=', '>', '<', '=', '~']) {
+        const opIdx = rest.indexOf(op);
+        if (opIdx > 0) {
+            const propName = rest.slice(0, opIdx);
+            const value = rest.slice(opIdx + op.length);
+            const mappedOp = op === '~' ? 'contains' : op;
+            return { psetName, propName, operator: mappedOp, value };
+        }
+    }
+    // No operator found — exists check
+    return { psetName, propName: rest, operator: 'exists' };
+}
 export async function queryCommand(args) {
     const filePath = args.find(a => !a.startsWith('-'));
     if (!filePath)
@@ -30,18 +110,236 @@ export async function queryCommand(args) {
     const jsonOutput = hasFlag(args, '--json');
     const countOnly = hasFlag(args, '--count');
     const spatial = hasFlag(args, '--spatial');
+    const sumQuantity = getFlag(args, '--sum');
+    const storeyFilter = getFlag(args, '--storey');
+    const quantityNames = hasFlag(args, '--quantity-names');
+    const propertyNames = hasFlag(args, '--property-names');
+    const uniqueProp = getFlag(args, '--unique');
+    const groupBy = getFlag(args, '--group-by');
+    const spatialSummary = hasFlag(args, '--summary');
     const { bim } = await createHeadlessContext(filePath);
+    // --quantity-names: list available quantities per entity type
+    if (quantityNames) {
+        const targetType = type;
+        if (!targetType)
+            fatal('--quantity-names requires --type (e.g., --type IfcWall --quantity-names)');
+        const entities = bim.query().byType(...targetType.split(',')).limit(50).toArray();
+        // Collect all quantity names seen, grouped by qset
+        const qsetMap = {};
+        for (const e of entities) {
+            const qsets = bim.quantities(e.ref);
+            for (const qset of qsets) {
+                if (!qsetMap[qset.name])
+                    qsetMap[qset.name] = new Map();
+                const qmap = qsetMap[qset.name];
+                for (const q of qset.quantities) {
+                    const existing = qmap.get(q.name);
+                    const numVal = Number(q.value) || 0;
+                    if (existing) {
+                        existing.count++;
+                        if (existing.sampleValues.length < 3)
+                            existing.sampleValues.push(numVal);
+                    }
+                    else {
+                        qmap.set(q.name, { count: 1, sampleValues: [numVal] });
+                    }
+                }
+            }
+        }
+        if (jsonOutput) {
+            const result = {};
+            for (const [qsetName, qmap] of Object.entries(qsetMap)) {
+                result[qsetName] = {};
+                for (const [qName, info] of qmap) {
+                    result[qsetName][qName] = {
+                        foundIn: `${info.count}/${entities.length} entities`,
+                        sampleValues: info.sampleValues,
+                        fullReference: `${qsetName}.${qName}`,
+                    };
+                }
+            }
+            // Add standard reference if available
+            const stdRef = STANDARD_QTO_MAP[targetType];
+            if (stdRef) {
+                printJson({ availableQuantities: result, standardReference: stdRef, note: 'Use --sum <QuantityName> to aggregate. Use full QsetName.QuantityName for unambiguous reference.' });
+            }
+            else {
+                printJson({ availableQuantities: result, note: 'Use --sum <QuantityName> to aggregate.' });
+            }
+        }
+        else {
+            process.stdout.write(`\nQuantities available for ${targetType} (sampled ${entities.length} entities):\n\n`);
+            for (const [qsetName, qmap] of Object.entries(qsetMap)) {
+                process.stdout.write(`  ${qsetName}:\n`);
+                for (const [qName, info] of qmap) {
+                    const samples = info.sampleValues.map(v => v.toFixed(2)).join(', ');
+                    process.stdout.write(`    ${qName}  (${info.count}/${entities.length} entities)  samples: [${samples}]\n`);
+                }
+                process.stdout.write('\n');
+            }
+            // Warn about ambiguity
+            const allNames = new Map();
+            for (const [qsetName, qmap] of Object.entries(qsetMap)) {
+                for (const qName of qmap.keys()) {
+                    const sets = allNames.get(qName) ?? [];
+                    sets.push(qsetName);
+                    allNames.set(qName, sets);
+                }
+            }
+            const areaNames = [...allNames.entries()].filter(([name]) => name.toLowerCase().includes('area') || name.toLowerCase().includes('surface'));
+            if (areaNames.length > 1) {
+                process.stderr.write(`WARNING: Multiple area quantities found. Choose carefully:\n`);
+                for (const [name, sets] of areaNames) {
+                    process.stderr.write(`  - ${name} (in ${sets.join(', ')})\n`);
+                }
+                process.stderr.write(`  Use --sum <exact-name> with the correct quantity for your analysis.\n\n`);
+            }
+        }
+        return;
+    }
+    // --property-names: list available properties per entity type
+    if (propertyNames) {
+        const targetType = type;
+        if (!targetType)
+            fatal('--property-names requires --type (e.g., --type IfcWall --property-names)');
+        const entities = bim.query().byType(...targetType.split(',')).limit(50).toArray();
+        const psetMap = {};
+        for (const e of entities) {
+            const psets = bim.properties(e.ref);
+            for (const pset of psets) {
+                if (!psetMap[pset.name])
+                    psetMap[pset.name] = new Map();
+                const pmap = psetMap[pset.name];
+                for (const p of pset.properties) {
+                    const existing = pmap.get(p.name);
+                    const strVal = p.value != null ? String(p.value) : '';
+                    if (existing) {
+                        existing.count++;
+                        if (existing.sampleValues.length < 3 && strVal && !existing.sampleValues.includes(strVal)) {
+                            existing.sampleValues.push(strVal);
+                        }
+                    }
+                    else {
+                        pmap.set(p.name, { count: 1, sampleValues: strVal ? [strVal] : [] });
+                    }
+                }
+            }
+        }
+        if (jsonOutput) {
+            const result = {};
+            for (const [psetName, pmap] of Object.entries(psetMap)) {
+                result[psetName] = {};
+                for (const [propName, info] of pmap) {
+                    result[psetName][propName] = {
+                        foundIn: `${info.count}/${entities.length} entities`,
+                        sampleValues: info.sampleValues,
+                        filterPath: `${psetName}.${propName}`,
+                    };
+                }
+            }
+            printJson({ availableProperties: result, note: 'Use --where PsetName.PropName=Value to filter.' });
+        }
+        else {
+            process.stdout.write(`\nProperties available for ${targetType} (sampled ${entities.length} entities):\n\n`);
+            for (const [psetName, pmap] of Object.entries(psetMap)) {
+                process.stdout.write(`  ${psetName}:\n`);
+                for (const [propName, info] of pmap) {
+                    const samples = info.sampleValues.length > 0 ? `  samples: [${info.sampleValues.map(v => `"${v}"`).join(', ')}]` : '';
+                    process.stdout.write(`    ${propName}  (${info.count}/${entities.length} entities)${samples}\n`);
+                }
+                process.stdout.write('\n');
+            }
+        }
+        return;
+    }
+    // --unique: distinct values for a property path (PsetName.PropName)
+    if (uniqueProp) {
+        const targetType = type;
+        if (!targetType)
+            fatal('--unique requires --type (e.g., --type IfcWall --unique PsetName.PropName)');
+        const dotIdx = uniqueProp.indexOf('.');
+        if (dotIdx <= 0)
+            fatal(`Invalid --unique path: "${uniqueProp}". Expected: PsetName.PropName`);
+        const psetName = uniqueProp.slice(0, dotIdx);
+        const propName = uniqueProp.slice(dotIdx + 1);
+        const entities = bim.query().byType(...targetType.split(',')).toArray();
+        const valueCounts = new Map();
+        for (const e of entities) {
+            const psets = bim.properties(e.ref);
+            const pset = psets.find((p) => p.name === psetName);
+            const prop = pset?.properties?.find((p) => p.name === propName);
+            const val = prop?.value != null ? String(prop.value) : '(no value)';
+            valueCounts.set(val, (valueCounts.get(val) ?? 0) + 1);
+        }
+        if (jsonOutput) {
+            const result = {};
+            for (const [val, count] of valueCounts)
+                result[val] = count;
+            printJson({ property: uniqueProp, distinctValues: result, totalEntities: entities.length });
+        }
+        else {
+            const sorted = [...valueCounts.entries()].sort((a, b) => b[1] - a[1]);
+            for (const [val, count] of sorted) {
+                process.stdout.write(`${val} (${count})\n`);
+            }
+            process.stderr.write(`\n${sorted.length} distinct values across ${entities.length} entities\n`);
+        }
+        return;
+    }
     // Spatial tree mode
     if (spatial) {
         const storeys = bim.storeys();
         const tree = {};
-        for (const storey of storeys) {
-            const contained = bim.contains(storey.ref);
-            tree[storey.name || `Storey #${storey.ref.expressId}`] = contained.map(e => ({
-                type: e.type,
-                name: e.name,
-                globalId: e.globalId,
-            }));
+        if (storeys.length > 0) {
+            for (const storey of storeys) {
+                const contained = bim.contains(storey.ref);
+                tree[storey.name || `Storey #${storey.ref.expressId}`] = contained.map(e => ({
+                    type: e.type,
+                    name: e.name,
+                    globalId: e.globalId,
+                }));
+            }
+        }
+        else {
+            // Fall back to buildings when no storeys exist
+            const buildings = bim.query().byType('IfcBuilding').toArray();
+            for (const building of buildings) {
+                const contained = bim.contains(building.ref);
+                tree[building.name || `Building #${building.ref.expressId}`] = contained.map(e => ({
+                    type: e.type,
+                    name: e.name,
+                    globalId: e.globalId,
+                }));
+            }
+            if (buildings.length === 0) {
+                process.stderr.write('No storeys or buildings found in spatial structure\n');
+            }
+        }
+        if (spatialSummary) {
+            // Summary mode: type counts per storey instead of listing every element
+            const summary = {};
+            for (const [storeyName, elements] of Object.entries(tree)) {
+                const counts = {};
+                for (const elem of elements) {
+                    counts[elem.type] = (counts[elem.type] || 0) + 1;
+                }
+                summary[storeyName] = counts;
+            }
+            if (jsonOutput) {
+                printJson(summary);
+            }
+            else {
+                for (const [storeyName, counts] of Object.entries(summary)) {
+                    const total = Object.values(counts).reduce((a, b) => a + b, 0);
+                    process.stdout.write(`\n  ${storeyName} (${total} elements):\n`);
+                    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+                    for (const [typeName, count] of sorted) {
+                        process.stdout.write(`    ${typeName}: ${count}\n`);
+                    }
+                }
+                process.stdout.write('\n');
+            }
+            return;
         }
         printJson(tree);
         return;
@@ -52,42 +350,270 @@ export async function queryCommand(args) {
         const types = type.split(',');
         q = q.byType(...types);
     }
-    if (propFilter) {
-        // Format: "PsetName.PropName=Value" or "PsetName.PropName"
-        const eqIdx = propFilter.indexOf('=');
-        const dotIdx = propFilter.indexOf('.');
-        if (dotIdx > 0) {
-            const psetName = propFilter.slice(0, dotIdx);
-            if (eqIdx > dotIdx) {
-                const propName = propFilter.slice(dotIdx + 1, eqIdx);
-                const value = propFilter.slice(eqIdx + 1);
-                q = q.where(psetName, propName, '=', value);
+    // --storey filter: restrict to entities in a specific storey
+    if (storeyFilter) {
+        const storeys = bim.storeys();
+        const matchedStorey = storeys.find(s => s.name === storeyFilter ||
+            s.name.toLowerCase().includes(storeyFilter.toLowerCase()) ||
+            String(s.ref.expressId) === storeyFilter);
+        if (!matchedStorey) {
+            const names = storeys.map(s => s.name).filter(Boolean).join(', ');
+            fatal(`Storey "${storeyFilter}" not found. Available: ${names || '(none)'}`);
+        }
+        const contained = bim.contains(matchedStorey.ref);
+        const storeyIds = new Set(contained.map(e => e.ref.expressId));
+        // Post-filter: only keep entities that are in this storey
+        const baseEntities = q.toArray();
+        const storeyEntities = baseEntities.filter(e => storeyIds.has(e.ref.expressId));
+        // Apply --where filter to storey-filtered entities
+        if (propFilter) {
+            const parsed = parseWhereFilter(propFilter);
+            // Re-apply via manual filtering since we've already resolved entities
+            const finalEntities = storeyEntities.filter(e => {
+                const props = bim.properties(e.ref);
+                const pset = props.find(p => p.name === parsed.psetName);
+                if (!pset)
+                    return false;
+                const prop = pset.properties.find((p) => p.name === parsed.propName);
+                if (!prop)
+                    return false;
+                if (parsed.operator === 'exists')
+                    return true;
+                return String(prop.value) === String(parsed.value);
+            });
+            if (sumQuantity) {
+                outputSum(finalEntities, sumQuantity, bim, jsonOutput);
+                return;
             }
-            else {
-                const propName = propFilter.slice(dotIdx + 1);
-                q = q.where(psetName, propName, 'exists');
+            if (countOnly) {
+                outputCount(finalEntities.length, jsonOutput);
+                return;
             }
+            outputEntities(finalEntities, args, bim, jsonOutput);
+            return;
+        }
+        if (sumQuantity) {
+            outputSum(storeyEntities, sumQuantity, bim, jsonOutput);
+            return;
+        }
+        if (countOnly) {
+            outputCount(storeyEntities.length, jsonOutput);
+            return;
         }
+        outputEntities(storeyEntities, args, bim, jsonOutput);
+        return;
+    }
+    // --where filter with proper syntax validation
+    if (propFilter) {
+        const parsed = parseWhereFilter(propFilter);
+        q = q.where(parsed.psetName, parsed.propName, parsed.operator, parsed.value);
     }
     if (limit)
         q = q.limit(parseInt(limit, 10));
     if (offset)
         q = q.offset(parseInt(offset, 10));
+    // --group-by + --sum combo: aggregate per group
+    if (groupBy && sumQuantity) {
+        const entities = q.toArray();
+        outputGroupBy(entities, groupBy, sumQuantity, bim, jsonOutput);
+        return;
+    }
+    // --sum mode: aggregate a quantity across matched entities
+    if (sumQuantity) {
+        const entities = q.toArray();
+        outputSum(entities, sumQuantity, bim, jsonOutput);
+        return;
+    }
+    // --group-by mode: pivot table grouped by a property or 'type'/'material'
+    if (groupBy) {
+        const entities = q.toArray();
+        outputGroupBy(entities, groupBy, undefined, bim, jsonOutput);
+        return;
+    }
     if (countOnly) {
         const count = q.count();
-        if (jsonOutput) {
-            printJson({ count });
+        outputCount(count, jsonOutput);
+        return;
+    }
+    const entities = q.toArray();
+    outputEntities(entities, args, bim, jsonOutput);
+}
+function outputCount(count, jsonOutput) {
+    if (jsonOutput) {
+        printJson({ count });
+    }
+    else {
+        process.stdout.write(`${count}\n`);
+    }
+}
+function outputSum(entities, quantityName, bim, jsonOutput) {
+    let total = 0;
+    let matched = 0;
+    // Track all quantity names seen (for disambiguation warning)
+    const allQuantityNames = new Map();
+    const matchedQsets = new Set();
+    for (const e of entities) {
+        const qsets = bim.quantities(e.ref);
+        for (const qset of qsets) {
+            for (const q of qset.quantities) {
+                // Track all quantities for disambiguation
+                const key = `${qset.name}.${q.name}`;
+                const existing = allQuantityNames.get(key);
+                if (existing) {
+                    existing.count++;
+                }
+                else {
+                    allQuantityNames.set(key, { qsetName: qset.name, count: 1 });
+                }
+                if (q.name === quantityName) {
+                    total += Number(q.value) || 0;
+                    matched++;
+                    matchedQsets.add(qset.name);
+                }
+            }
+        }
+    }
+    // Check for ambiguous area/volume quantities and warn
+    const similarNames = [...allQuantityNames.entries()]
+        .filter(([key]) => {
+        const qName = key.split('.').pop().toLowerCase();
+        const searchName = quantityName.toLowerCase();
+        // Warn if there are other quantities with similar base concept (area, volume, etc.)
+        if (searchName.includes('area'))
+            return qName.includes('area') || qName.includes('surface');
+        if (searchName.includes('volume'))
+            return qName.includes('volume');
+        if (searchName.includes('length'))
+            return qName.includes('length');
+        return false;
+    })
+        .filter(([key]) => key.split('.').pop() !== quantityName);
+    if (jsonOutput) {
+        const result = {
+            quantity: quantityName,
+            total,
+            matchedEntities: matched,
+            totalEntities: entities.length,
+            fromQuantitySets: [...matchedQsets],
+        };
+        if (similarNames.length > 0) {
+            result.warning = 'Other similar quantities exist — verify you are using the correct one';
+            result.alternatives = similarNames.map(([key, info]) => ({
+                name: key,
+                foundInEntities: info.count,
+            }));
+        }
+        printJson(result);
+    }
+    else {
+        process.stdout.write(`${total}\n`);
+        process.stderr.write(`${quantityName}: ${total} (from ${matched} of ${entities.length} entities, qsets: ${[...matchedQsets].join(', ')})\n`);
+        if (similarNames.length > 0) {
+            process.stderr.write(`\nWARNING: Other similar quantities exist in these entities:\n`);
+            for (const [key, info] of similarNames) {
+                process.stderr.write(`  - ${key} (${info.count} entities)\n`);
+            }
+            process.stderr.write(`  Verify you are summing the correct quantity for your analysis.\n`);
+            process.stderr.write(`  Use --quantity-names --type <Type> to see all available quantities.\n`);
+        }
+    }
+}
+function outputGroupBy(entities, groupByKey, sumQuantity, bim, jsonOutput) {
+    const groups = new Map();
+    for (const e of entities) {
+        let groupValue;
+        if (groupByKey === 'type') {
+            groupValue = e.type;
+        }
+        else if (groupByKey === 'storey') {
+            const storey = bim.storey(e.ref);
+            groupValue = storey?.name ?? '(no storey)';
+        }
+        else if (groupByKey === 'material') {
+            const mat = bim.materials(e.ref);
+            groupValue = mat?.materials?.[0]?.name ?? mat?.name ?? '(no material)';
+        }
+        else if (groupByKey.includes('.')) {
+            // PsetName.PropName
+            const [psetName, propName] = groupByKey.split('.', 2);
+            const props = bim.properties(e.ref);
+            const pset = props.find((p) => p.name === psetName);
+            const prop = pset?.properties?.find((p) => p.name === propName);
+            groupValue = prop?.value != null ? String(prop.value) : `(no ${propName})`;
         }
         else {
-            process.stdout.write(`${count}\n`);
+            groupValue = e[groupByKey] ?? `(no ${groupByKey})`;
+        }
+        const existing = groups.get(groupValue);
+        if (existing) {
+            existing.push(e);
+        }
+        else {
+            groups.set(groupValue, [e]);
         }
-        return;
     }
-    const entities = q.toArray();
+    // Compute per-group sum if --sum is specified alongside --group-by
+    const groupSums = new Map();
+    if (sumQuantity) {
+        for (const [key, groupEntities] of groups) {
+            let sum = 0;
+            for (const e of groupEntities) {
+                const qsets = bim.quantities(e.ref);
+                for (const qset of qsets) {
+                    for (const q of qset.quantities) {
+                        if (q.name === sumQuantity)
+                            sum += Number(q.value) || 0;
+                    }
+                }
+            }
+            groupSums.set(key, sum);
+        }
+    }
+    if (jsonOutput) {
+        const result = {};
+        for (const [key, groupEntities] of groups) {
+            const entry = { count: groupEntities.length };
+            if (sumQuantity)
+                entry[sumQuantity] = groupSums.get(key) ?? 0;
+            result[key] = entry;
+        }
+        printJson(result);
+    }
+    else {
+        const sorted = [...groups.entries()].sort((a, b) => b[1].length - a[1].length);
+        process.stdout.write(`\nGrouped by ${groupByKey}${sumQuantity ? ` (sum: ${sumQuantity})` : ''}:\n\n`);
+        for (const [key, groupEntities] of sorted) {
+            if (sumQuantity) {
+                const sum = groupSums.get(key) ?? 0;
+                process.stdout.write(`  ${key}:  ${groupEntities.length} elements,  ${sumQuantity}: ${sum}\n`);
+            }
+            else {
+                process.stdout.write(`  ${key}: ${groupEntities.length}\n`);
+            }
+        }
+        if (sumQuantity) {
+            const grandTotal = [...groupSums.values()].reduce((a, b) => a + b, 0);
+            process.stdout.write(`\n  Total: ${entities.length} entities in ${groups.size} groups, ${sumQuantity}: ${grandTotal}\n\n`);
+        }
+        else {
+            process.stdout.write(`\n  Total: ${entities.length} entities in ${groups.size} groups\n\n`);
+        }
+    }
+}
+function outputEntities(entities, args, bim, jsonOutput) {
+    const showProps = hasFlag(args, '--props');
+    const showQuantities = hasFlag(args, '--quantities');
+    const showMaterials = hasFlag(args, '--materials');
+    const showClassifications = hasFlag(args, '--classifications');
+    const showAttributes = hasFlag(args, '--attributes');
+    const showRelationships = hasFlag(args, '--relationships');
+    const showTypeProps = hasFlag(args, '--type-props');
+    const showDocuments = hasFlag(args, '--documents');
+    const showAll = hasFlag(args, '--all');
     const needsDetail = showProps || showQuantities || showMaterials || showClassifications
         || showAttributes || showRelationships || showTypeProps || showDocuments || showAll;
     if (jsonOutput || needsDetail) {
-        const result = entities.map(e => {
+        const result = entities.map((e) => {
             const entry = {
                 type: e.type,
                 name: e.name,
@@ -117,7 +643,7 @@ export async function queryCommand(args) {
         return;
     }
     // Table output
-    const rows = entities.map(e => [e.type, e.name, e.globalId]);
+    const rows = entities.map((e) => [e.type, e.name, e.globalId]);
     process.stdout.write(formatTable(['Type', 'Name', 'GlobalId'], rows) + '\n');
     process.stderr.write(`\n${entities.length} entities\n`);
 }