@dssp/dkpi 1.0.0-y.0 → 1.0.1

package/dist-server/scripts/propagate-parent-kpi-values.js

@@ -1,9 +1,176 @@
 #!/usr/bin/env ts-node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateParentKpiValuesBatch = propagateParentKpiValuesBatch;
 exports.propagateParentKpiValues = propagateParentKpiValues;
 exports.listParentKpiHierarchy = listParentKpiHierarchy;
 const typeorm_1 = require("typeorm");
+/**
+ * Batch process multiple organizations with single initialization (optimized for performance)
+ */
+async function propagateParentKpiValuesBatch(orgScopes, specificKpiName, forceRecalculate = false, targetDate, version) {
+    // Set NODE_ENV if not set
+    if (!process.env.NODE_ENV) {
+        process.env.NODE_ENV = 'development';
+    }
+    // Initialize Things-Factory environment (ONCE)
+    const { config } = require('@things-factory/env');
+    const ormconfig = require('@things-factory/shell/dist-server/initializers/ormconfig.js');
+    const connectionConfig = config.get('ormconfig');
+    let connection;
+    console.log('🚀 Starting Batch Parent KPI Value Propagation...');
+    console.log(`📦 Processing ${orgScopes.length} organizations`);
+    try {
+        // Create database connection using Things-Factory pattern (ONCE)
+        console.log('🔌 Connecting to database...');
+        connection = await (0, typeorm_1.createConnection)(Object.assign(Object.assign(Object.assign({}, ormconfig), connectionConfig), { logging: false }));
+        // Register the connection with Things-Factory shell
+        const { addDataSource } = require('@things-factory/shell');
+        addDataSource('default', connection);
+        console.log('✅ Database connected');
+        let totalProcessed = 0;
+        let totalCreated = 0;
+        let totalErrors = 0;
+        const startTime = Date.now();
+        // Process each organization
+        for (let i = 0; i < orgScopes.length; i++) {
+            const orgScope = orgScopes[i].trim();
+            console.log(`\n[${i + 1}/${orgScopes.length}] 🏢 Processing org: ${orgScope}`);
+            try {
+                // Call the core processing logic for single org
+                const result = await processSingleOrg(connection, orgScope, specificKpiName, forceRecalculate, targetDate, version);
+                totalProcessed += result.processed;
+                totalCreated += result.created;
+                console.log(`   ✅ Success: ${result.created} parent KPIs created`);
+            }
+            catch (error) {
+                totalErrors++;
+                console.log(`   ❌ Failed: ${error.message}`);
+            }
+        }
+        const endTime = Date.now();
+        const duration = ((endTime - startTime) / 1000).toFixed(2);
+        console.log(`\n🎉 Batch Propagation Complete!`);
+        console.log(`   📊 Organizations processed: ${orgScopes.length}`);
+        console.log(`   ✨ Parent KPIs created: ${totalCreated}`);
+        console.log(`   ❌ Errors: ${totalErrors}`);
+        console.log(`   ⏱️  Duration: ${duration}s (${(parseFloat(duration) / orgScopes.length).toFixed(2)}s per org)`);
+    }
+    catch (error) {
+        console.error(`❌ Fatal error during batch propagation:`, error);
+        throw error;
+    }
+    finally {
+        if (connection) {
+            await connection.close();
+            console.log('🔌 Database connection closed');
+        }
+    }
+}
+/**
+ * Process single organization (used by batch processor)
+ */
+async function processSingleOrg(connection, orgScope, specificKpiName, forceRecalculate = false, targetDate, version) {
+    const { getRepository } = require('@things-factory/shell');
+    const { Kpi, KpiValue } = require('@things-factory/kpi');
+    const { Domain } = require('@things-factory/shell');
+    const kpiRepository = getRepository(Kpi);
+    const kpiValueRepository = getRepository(KpiValue);
+    const domainRepository = getRepository(Domain);
+    const systemDomain = await domainRepository.findOne({ where: { name: 'SYSTEM' } });
+    if (!systemDomain) {
+        throw new Error('SYSTEM domain not found');
+    }
+    // Get all KPIs with their hierarchy
+    let kpisQuery = kpiRepository
+        .createQueryBuilder('kpi')
+        .leftJoinAndSelect('kpi.domain', 'domain')
+        .leftJoinAndSelect('kpi.parent', 'parent')
+        .leftJoinAndSelect('kpi.children', 'children')
+        .where('kpi.domain_id = :domainId', { domainId: systemDomain.id });
+    if (specificKpiName) {
+        kpisQuery = kpisQuery.andWhere('kpi.name = :name', { name: specificKpiName });
+    }
+    const allKpis = await kpisQuery.getMany();
+    const parentKpis = allKpis.filter((kpi) => !kpi.isLeaf);
+    const leafKpis = allKpis.filter((kpi) => kpi.isLeaf);
+    console.log(`   📊 KPIs: ${allKpis.length} total (${leafKpis.length} leaf, ${parentKpis.length} parent)`);
+    // 1. Recalculate leaf KPI scores
+    await recalculateLeafKpiScores(kpiRepository, kpiValueRepository, leafKpis, orgScope, targetDate);
+    // 2. Delete existing parent KPI values
+    if (parentKpis.length > 0) {
+        const parentKpiIds = parentKpis.map((kpi) => kpi.id);
+        let deleteQuery = kpiValueRepository
+            .createQueryBuilder('kpiValue')
+            .delete()
+            .where('kpi_id IN (:...kpiIds)', { kpiIds: parentKpiIds })
+            .andWhere('domain_id = (SELECT id FROM domains WHERE name = :domainName)', { domainName: 'SYSTEM' })
+            .andWhere('"group" = :orgScope', { orgScope });
+        if (targetDate) {
+            deleteQuery = deleteQuery.andWhere('value_date = :targetDate', { targetDate });
+        }
+        await deleteQuery.execute();
+    }
+    // 3. Sort parent KPIs and get combinations
+    const sortedParentKpis = await sortKpisByLevel(parentKpis, allKpis);
+    let groupDateCombinations = [];
+    if (targetDate) {
+        groupDateCombinations = [{ group: orgScope, valueDate: targetDate }];
+    }
+    else {
+        const dates = await kpiValueRepository.query(`SELECT DISTINCT "value_date" FROM kpi_values WHERE "group" = $1 AND "group" IS NOT NULL ORDER BY "value_date"`, [orgScope]);
+        groupDateCombinations = dates.map((row) => ({ group: orgScope, valueDate: row.value_date }));
+    }
+    console.log(`   📅 Date combinations: ${groupDateCombinations.length}`);
+    let totalCreated = 0;
+    // 4. Process each parent KPI
+    for (const { group: currentGroup, valueDate } of groupDateCombinations) {
+        console.log(`   📆 Processing date: ${valueDate}`);
+        for (const parentKpi of sortedParentKpis) {
+            const childKpis = allKpis.filter((kpi) => { var _a; return ((_a = kpi.parent) === null || _a === void 0 ? void 0 : _a.id) === parentKpi.id; });
+            if (childKpis.length === 0)
+                continue;
+            const childValues = await getChildKpiValues(kpiValueRepository, childKpis, valueDate, version, currentGroup);
+            if (childValues.length === 0)
+                continue;
+            let calculatedValue;
+            let calculatedScore;
+            if (parentKpi.formula) {
+                try {
+                    const result = await calculateParentKpiWithFormula(parentKpi, childValues, childKpis);
+                    calculatedValue = result.value;
+                    calculatedScore = result.score;
+                }
+                catch (formulaError) {
+                    const { weightedValue, weightedScore } = calculateWeightedAverage(childValues, childKpis);
+                    calculatedValue = weightedValue;
+                    calculatedScore = weightedScore;
+                }
+            }
+            else {
+                const { weightedValue, weightedScore } = calculateWeightedAverage(childValues, childKpis);
+                calculatedValue = weightedValue;
+                calculatedScore = weightedScore;
+            }
+            const newKpiValue = {
+                kpi: parentKpi,
+                value: calculatedValue,
+                score: calculatedScore,
+                valueDate: valueDate,
+                version: parentKpi.version || 1,
+                group: currentGroup,
+                kpiScope: currentGroup,
+                domain: systemDomain,
+                inputType: 'AUTO',
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            await kpiValueRepository.save(newKpiValue);
+            totalCreated++;
+        }
+    }
+    return { processed: sortedParentKpis.length, created: totalCreated };
+}
 /**
  * Propagate parent KPI values based on child KPI scores and weights
  * Processes hierarchy from leaf to root, calculating weighted averages
@@ -85,11 +252,31 @@ async function propagateParentKpiValues(specificKpiName, forceRecalculate = fals
         // Sort parent KPIs by hierarchy level (deepest first for bottom-up processing)
         const sortedParentKpis = await sortKpisByLevel(parentKpis, allKpis);
         console.log(`🔄 Processing ${sortedParentKpis.length} parent KPIs`);
+        // 1. First, recalculate leaf KPI scores using latest KPI versions and grades
+        const leafKpis = allKpis.filter(kpi => kpi.isLeaf);
+        console.log(`\n📊 Step 1: Recalculating ${leafKpis.length} leaf KPI scores with latest KPI grades...`);
+        await recalculateLeafKpiScores(kpiRepository, kpiValueRepository, leafKpis, orgScope, targetDate);
+        // 2. Delete existing parent KPI values (not leaf values - they are base data)
+        console.log('\n🗑️  Step 2: Deleting existing parent KPI values...');
+        const parentKpiIds = parentKpis.map((kpi) => kpi.id);
+        let deleteQuery = kpiValueRepository
+            .createQueryBuilder('kpiValue')
+            .delete()
+            .where('kpi_id IN (:...kpiIds)', { kpiIds: parentKpiIds })
+            .andWhere('domain_id = (SELECT id FROM domains WHERE name = :domainName)', { domainName: 'SYSTEM' });
+        if (orgScope) {
+            deleteQuery = deleteQuery.andWhere('"group" = :orgScope', { orgScope });
+        }
+        if (targetDate) {
+            deleteQuery = deleteQuery.andWhere('value_date = :targetDate', { targetDate });
+        }
+        const deleteResult = await deleteQuery.execute();
+        console.log(`✅ Deleted ${deleteResult.affected || 0} existing parent KPI values`);
         let totalProcessed = 0;
         let totalCreated = 0;
-        let totalUpdated = 0;
         let errorCount = 0;
-        // Get all distinct (group, valueDate) combinations from existing KPI values
+        // 3. Get all distinct (group, valueDate) combinations from existing KPI values
+        console.log('\n📍 Step 3: Creating parent KPI values from recalculated leaf scores...');
         let groupDateCombinations = [];
         if (orgScope && targetDate) {
             groupDateCombinations = [{ group: orgScope, valueDate: targetDate }];
@@ -97,24 +284,24 @@ async function propagateParentKpiValues(specificKpiName, forceRecalculate = fals
         else if (orgScope) {
             // Get all dates for specific group
             const dates = await kpiValueRepository.query(`
-        SELECT DISTINCT "value_date" 
-        FROM kpi_values 
+        SELECT DISTINCT "value_date"
+        FROM kpi_values
         WHERE "group" = $1 AND "group" IS NOT NULL
         ORDER BY "value_date"
       `, [orgScope]);
-            groupDateCombinations = dates.map(row => ({ group: orgScope, valueDate: row.value_date }));
+            groupDateCombinations = dates.map((row) => ({ group: orgScope, valueDate: row.value_date }));
         }
         else {
             // Get all distinct (group, valueDate) combinations
             const combinations = await kpiValueRepository.query(`
-        SELECT DISTINCT "group", "value_date" 
-        FROM kpi_values 
+        SELECT DISTINCT "group", "value_date"
+        FROM kpi_values
         WHERE "group" IS NOT NULL AND "group" != ''
         ORDER BY "group", "value_date"
       `);
-            groupDateCombinations = combinations.map(row => ({ group: row.group, valueDate: row.value_date }));
+            groupDateCombinations = combinations.map((row) => ({ group: row.group, valueDate: row.value_date }));
         }
-        console.log(`📍 Found ${groupDateCombinations.length} distinct (group, date) combinations`);
+        console.log(`   Found ${groupDateCombinations.length} distinct (group, date) combinations`);
         // Process each (group, date) combination
         for (const { group: currentGroup, valueDate } of groupDateCombinations) {
             console.log(`\\n🏢 Processing Group: ${currentGroup}, Date: ${valueDate}`);
@@ -136,71 +323,56 @@ async function propagateParentKpiValues(specificKpiName, forceRecalculate = fals
                         continue;
                     }
                     console.log(`   📊 Found values for ${childValues.length}/${childKpis.length} child KPIs`);
-                    // Calculate weighted average
-                    const { weightedValue, weightedScore } = calculateWeightedAverage(childValues, childKpis);
-                    console.log(`   🧮 Calculated: value=${weightedValue.toFixed(4)}, score=${weightedScore.toFixed(4)}`);
-                    // Check if parent KPI value already exists for this org scope
-                    let existingValueQuery = kpiValueRepository
-                        .createQueryBuilder('kpiValue')
-                        .leftJoinAndSelect('kpiValue.kpi', 'kpi')
-                        .leftJoinAndSelect('kpiValue.domain', 'domain')
-                        .where('kpi.id = :kpiId', { kpiId: parentKpi.id })
-                        .andWhere('kpiValue.valueDate = :valueDate', { valueDate })
-                        .andWhere('domain.name = :domainName', { domainName: 'SYSTEM' });
-                    if (version !== undefined) {
-                        existingValueQuery = existingValueQuery.andWhere('kpiValue.version = :version', { version });
-                    }
-                    // Filter by group scope
-                    existingValueQuery = existingValueQuery.andWhere('kpiValue.group = :groupScope', { groupScope: currentGroup });
-                    const existingValue = await existingValueQuery.getOne();
-                    console.log(`   🔍 Checking existing record: ${existingValue ? 'FOUND' : 'NOT FOUND'}`);
-                    if (existingValue) {
-                        // Update existing value
-                        if (forceRecalculate || existingValue.value !== weightedValue || existingValue.score !== weightedScore) {
-                            const oldValue = existingValue.value;
-                            const oldScore = existingValue.score;
-                            existingValue.value = weightedValue;
-                            existingValue.score = weightedScore;
-                            existingValue.kpiScope = currentGroup; // Set kpiScope same as group
-                            existingValue.updatedAt = new Date();
-                            try {
-                                await kpiValueRepository.save(existingValue);
-                                totalUpdated++;
-                                console.log(`     ✅ Updated: ${oldValue.toFixed(4)} → ${weightedValue.toFixed(4)}, score: ${oldScore.toFixed(4)} → ${weightedScore.toFixed(4)}`);
-                            }
-                            catch (saveError) {
-                                console.log(`     ❌ Update failed: ${saveError.message}`);
-                                errorCount++;
-                            }
+                    // Calculate parent KPI value and score
+                    let calculatedValue;
+                    let calculatedScore;
+                    // 1. If parent KPI has formula, use it to calculate
+                    if (parentKpi.formula) {
+                        try {
+                            console.log(`   📐 Using formula: ${parentKpi.formula}`);
+                            const result = await calculateParentKpiWithFormula(parentKpi, childValues, childKpis);
+                            calculatedValue = result.value;
+                            calculatedScore = result.score;
+                            console.log(`   🧮 Formula result: value=${calculatedValue.toFixed(4)}, score=${calculatedScore.toFixed(4)}`);
                         }
-                        else {
-                            console.log(`     ⏭️  No change needed`);
+                        catch (formulaError) {
+                            console.log(`   ⚠️  Formula evaluation failed: ${formulaError.message}, falling back to weighted average`);
+                            const { weightedValue, weightedScore } = calculateWeightedAverage(childValues, childKpis);
+                            calculatedValue = weightedValue;
+                            calculatedScore = weightedScore;
                         }
                     }
                     else {
-                        // Create new value with group scope
-                        const newKpiValue = {
-                            kpi: parentKpi,
-                            value: weightedValue,
-                            score: weightedScore,
-                            valueDate: valueDate,
-                            version: version || parentKpi.version || 1,
-                            group: currentGroup,
-                            kpiScope: currentGroup, // Set kpiScope same as group
-                            domain: systemDomain, // Set domain entity
-                            inputType: 'AUTO', // Set inputType to AUTO
-                            createdAt: new Date(),
-                            updatedAt: new Date()
-                        };
-                        try {
-                            const savedValue = await kpiValueRepository.save(newKpiValue);
-                            totalCreated++;
-                            console.log(`     ✨ Created: value=${weightedValue.toFixed(4)}, score=${weightedScore.toFixed(4)}, id=${savedValue.id}`);
-                        }
-                        catch (saveError) {
-                            console.log(`     ❌ Save failed: ${saveError.message}`);
-                            errorCount++;
-                        }
+                        // 2. If no formula, use weighted average
+                        console.log(`   ⚖️  Using weighted average`);
+                        const { weightedValue, weightedScore } = calculateWeightedAverage(childValues, childKpis);
+                        calculatedValue = weightedValue;
+                        calculatedScore = weightedScore;
+                        console.log(`   🧮 Weighted average: value=${calculatedValue.toFixed(4)}, score=${calculatedScore.toFixed(4)}`);
+                    }
+                    // Create new parent KPI value (old values already deleted)
+                    // Use latest KPI version (parentKpi.version) not the old value's version
+                    const newKpiValue = {
+                        kpi: parentKpi,
+                        value: calculatedValue,
+                        score: calculatedScore,
+                        valueDate: valueDate,
+                        version: parentKpi.version || 1, // Use latest KPI version
+                        group: currentGroup,
+                        kpiScope: currentGroup, // Set kpiScope same as group
+                        domain: systemDomain, // Set domain entity
+                        inputType: 'AUTO', // Set inputType to AUTO
+                        createdAt: new Date(),
+                        updatedAt: new Date()
+                    };
+                    try {
+                        const savedValue = await kpiValueRepository.save(newKpiValue);
+                        totalCreated++;
+                        console.log(`     ✨ Created: value=${calculatedValue.toFixed(4)}, score=${calculatedScore.toFixed(4)}, version=${parentKpi.version || 1}, id=${savedValue.id}`);
+                    }
+                    catch (saveError) {
+                        console.log(`     ❌ Save failed: ${saveError.message}`);
+                        errorCount++;
                     }
                     totalProcessed++;
                 }
@@ -213,7 +385,6 @@ async function propagateParentKpiValues(specificKpiName, forceRecalculate = fals
         console.log(`\\n🎉 Parent KPI Value Propagation Complete!`);
         console.log(`   📊 Parent KPIs processed: ${totalProcessed}`);
         console.log(`   ✨ Values created: ${totalCreated}`);
-        console.log(`   ✅ Values updated: ${totalUpdated}`);
         console.log(`   ❌ Errors: ${errorCount}`);
         if (errorCount > 0) {
             console.log(`\\n⚠️  Some parent KPIs had errors. Check the logs above for details.`);
@@ -263,18 +434,19 @@ async function sortKpisByLevel(parentKpis, allKpis) {
 }
 /**
  * Get child KPI values for a specific date
+ * Note: Version filter is NOT applied - uses latest available child KPI values regardless of version
+ * This matches the recalculateProjectKpiValues logic in kpi-metric-value-mutation.ts
  */
 async function getChildKpiValues(kpiValueRepository, childKpis, valueDate, version, orgScope) {
-    const childKpiIds = childKpis.map(kpi => kpi.id);
+    const childKpiIds = childKpis.map((kpi) => kpi.id);
     let valuesQuery = kpiValueRepository
         .createQueryBuilder('kpiValue')
         .leftJoinAndSelect('kpiValue.kpi', 'kpi')
         .where('kpi.id IN (:...kpiIds)', { kpiIds: childKpiIds })
         .andWhere('kpiValue.valueDate = :valueDate', { valueDate })
         .andWhere('kpiValue.score IS NOT NULL');
-    if (version !== undefined) {
-        valuesQuery = valuesQuery.andWhere('kpiValue.version = :version', { version });
-    }
+    // Version filter is intentionally removed to use latest available child KPI values
+    // This ensures we calculate parent KPIs based on the most recent child data
     // Filter by group scope
     if (orgScope) {
         valuesQuery = valuesQuery.andWhere('kpiValue.group = :groupScope', { groupScope: orgScope });
@@ -282,6 +454,161 @@ async function getChildKpiValues(kpiValueRepository, childKpis, valueDate, versi
     const values = await valuesQuery.getMany();
     return values;
 }
+/**
+ * Recalculate leaf KPI scores using latest KPI grades lookup table
+ */
+async function recalculateLeafKpiScores(kpiRepository, kpiValueRepository, leafKpis, orgScope, targetDate) {
+    var _a;
+    let totalRecalculated = 0;
+    let errorCount = 0;
+    for (const leafKpi of leafKpis) {
+        try {
+            // Get latest version of this KPI with grades
+            const latestKpi = await kpiRepository.findOne({
+                where: { id: leafKpi.id },
+                order: { version: 'DESC' }
+            });
+            if (!latestKpi) {
+                console.log(`   ⚠️  Latest KPI not found for ${leafKpi.name}`);
+                continue;
+            }
+            // Get all leaf KPI values that need score recalculation
+            let valuesQuery = kpiValueRepository
+                .createQueryBuilder('kpiValue')
+                .where('kpiValue.kpi_id = :kpiId', { kpiId: leafKpi.id })
+                .andWhere('kpiValue.value IS NOT NULL');
+            if (orgScope) {
+                valuesQuery = valuesQuery.andWhere('kpiValue.group = :orgScope', { orgScope });
+            }
+            if (targetDate) {
+                valuesQuery = valuesQuery.andWhere('kpiValue.value_date = :targetDate', { targetDate });
+            }
+            const kpiValues = await valuesQuery.getMany();
+            if (kpiValues.length === 0) {
+                continue;
+            }
+            // 2D lookup 여부 확인
+            const is2D = latestKpi.grades && !Array.isArray(latestKpi.grades) && latestKpi.grades.type === 'PROGRESS_DEVIATION_LOOKUP';
+            const progressRateCache = new Map();
+            let projectRepo = null;
+            if (is2D) {
+                try {
+                    const { Project } = require('@dssp/project');
+                    const { getRepository: getRepo } = require('@things-factory/shell');
+                    projectRepo = getRepo(Project);
+                }
+                catch (_b) {
+                    console.log(`   ⚠️  @dssp/project not found — using default progressRate for ${leafKpi.name}`);
+                }
+            }
+            // Recalculate score for each value using latest KPI grades
+            for (const kpiValue of kpiValues) {
+                const oldScore = kpiValue.score;
+                let progressRate;
+                if (is2D && kpiValue.group) {
+                    if (progressRateCache.has(kpiValue.group)) {
+                        progressRate = progressRateCache.get(kpiValue.group);
+                    }
+                    else if (projectRepo) {
+                        const project = await projectRepo.findOne({ where: { id: kpiValue.group } });
+                        progressRate = (_a = project === null || project === void 0 ? void 0 : project.totalProgress) !== null && _a !== void 0 ? _a : 50;
+                        progressRateCache.set(kpiValue.group, progressRate);
+                    }
+                }
+                const newScore = calculateScoreFromGrades(latestKpi, kpiValue.value, progressRate);
+                if (newScore !== null && newScore !== oldScore) {
+                    kpiValue.score = newScore;
+                    kpiValue.version = latestKpi.version || 1;
+                    await kpiValueRepository.save(kpiValue);
+                    totalRecalculated++;
+                    console.log(`   ✅ ${leafKpi.name}: score ${(oldScore === null || oldScore === void 0 ? void 0 : oldScore.toFixed(4)) || 'null'} → ${newScore.toFixed(4)} (version ${latestKpi.version || 1})`);
+                }
+            }
+        }
+        catch (error) {
+            console.log(`   ❌ Error recalculating scores for ${leafKpi.name}: ${error.message}`);
+            errorCount++;
+        }
+    }
+    console.log(`\n   📊 Leaf scores recalculated: ${totalRecalculated}, Errors: ${errorCount}`);
+}
+/**
+ * Calculate score from KPI grades lookup table
+ * 1D (기존 배열) 및 2D (X13 공정률×편차) lookup 모두 지원
+ */
+function calculateScoreFromGrades(kpi, value, progressRate) {
+    if (!kpi.grades) {
+        return null;
+    }
+    // 2D lookup table 처리 (X13: 공정률 × 편차 → 점수)
+    if (!Array.isArray(kpi.grades) && kpi.grades.type === 'PROGRESS_DEVIATION_LOOKUP') {
+        return calculate2DScore(value, kpi.grades, progressRate !== null && progressRate !== void 0 ? progressRate : 50);
+    }
+    // 1D lookup (기존)
+    if (!Array.isArray(kpi.grades) || kpi.grades.length === 0) {
+        return null;
+    }
+    const grade = kpi.grades.find((g) => value >= g.minValue && value <= g.maxValue);
+    if (!grade) {
+        return null;
+    }
+    return grade.score;
+}
+/**
+ * 2D lookup table에서 점수 계산 (X13: 공정률 × 편차 → 점수 1~5)
+ */
+function calculate2DScore(deviationValue, grades, progressRate) {
+    if (!grades.rows || !Array.isArray(grades.rows))
+        return null;
+    const progressIndex = Math.min(99, Math.max(0, Math.floor(progressRate)));
+    const row = grades.rows.find((r) => r.progressRate === progressIndex);
+    if (!row)
+        return null;
+    if (deviationValue < row.boundary5to4)
+        return 5;
+    if (deviationValue < row.boundary4to3)
+        return 4;
+    if (deviationValue < row.boundary3to2)
+        return 3;
+    if (deviationValue < row.boundary2to1)
+        return 2;
+    return 1;
+}
+/**
+ * Calculate parent KPI value using formula
+ * This matches the logic in kpi-metric-value-mutation.ts recalculateParentKpiValue
+ */
+async function calculateParentKpiWithFormula(parentKpi, childValues, childKpis) {
+    // Import formula evaluation functions
+    const { parseFormula, evaluateFormula, builtinFunctions } = require('@things-factory/kpi');
+    // Create child KPI name -> score mapping
+    const childKpiScoreMap = {};
+    childValues.forEach(kpiValue => {
+        var _a;
+        const childKpi = childKpis.find((k) => k.id === kpiValue.kpi.id);
+        if (childKpi) {
+            childKpiScoreMap[childKpi.name] = (_a = kpiValue.score) !== null && _a !== void 0 ? _a : 0;
+        }
+    });
+    // Create provider for formula evaluation
+    const provider = {
+        get: async (name) => {
+            const value = childKpiScoreMap[name];
+            if (value === undefined) {
+                throw new Error(`Child KPI '${name}' not found in parent KPI formula`);
+            }
+            return value;
+        }
+    };
+    // Parse and evaluate formula
+    const ast = parseFormula(parentKpi.formula);
+    const evalContext = { functions: builtinFunctions, provider };
+    const result = await evaluateFormula(ast, evalContext);
+    return {
+        value: result,
+        score: result
+    };
+}
 /**
  * Calculate weighted average from child KPI values
  */
@@ -376,6 +703,7 @@ Options:
   --force, -f          Force recalculate all values (not just missing ones)
   --date YYYY-MM-DD    Target date for value calculation (default: today)
   --org orgScope       Organization scope filter (default: all orgs)
+  --orgs org1,org2     Multiple organization scopes (comma-separated)
   --version N          KPI version filter (default: latest version)
   --help, -h           Show this help
 
@@ -384,12 +712,14 @@ Examples:
   ts-node server/scripts/propagate-parent-kpi-values.ts --force              # Recalculate ALL parent values
   ts-node server/scripts/propagate-parent-kpi-values.ts --date 2024-01-15    # Process for specific date
   ts-node server/scripts/propagate-parent-kpi-values.ts --org "PROJECT-123"  # Process for specific org
+  ts-node server/scripts/propagate-parent-kpi-values.ts --orgs "ID1,ID2,ID3" # Process multiple orgs
   ts-node server/scripts/propagate-parent-kpi-values.ts --version 2          # Process for specific version
   ts-node server/scripts/propagate-parent-kpi-values.ts "상위 KPI명"          # Process specific parent KPI
   ts-node server/scripts/propagate-parent-kpi-values.ts --list               # List parent KPI hierarchy
 
 Note: Processes parent KPIs from deepest level to root, calculating weighted averages.
       Child KPI scores and weights are used to calculate parent values.
+      --orgs option processes multiple orgs with single initialization (faster).
       `);
             return;
         }
@@ -402,10 +732,26 @@ Note: Processes parent KPIs from deepest level to root, calculating weighted ave
         const targetDate = dateIndex !== -1 && dateIndex + 1 < args.length ? args[dateIndex + 1] : undefined;
         const orgIndex = args.indexOf('--org');
         const orgScope = orgIndex !== -1 && orgIndex + 1 < args.length ? args[orgIndex + 1] : undefined;
+        const orgsIndex = args.indexOf('--orgs');
+        const orgScopesString = orgsIndex !== -1 && orgsIndex + 1 < args.length ? args[orgsIndex + 1] : undefined;
+        const orgScopes = orgScopesString ? orgScopesString.split(',') : undefined;
         const versionIndex = args.indexOf('--version');
         const version = versionIndex !== -1 && versionIndex + 1 < args.length ? parseInt(args[versionIndex + 1]) : undefined;
-        const specificKpiName = args.find(arg => !arg.startsWith('--') && arg !== targetDate && arg !== orgScope && (version === undefined || arg !== version.toString()));
-        if (specificKpiName) {
+        const specificKpiName = args.find(arg => !arg.startsWith('--') &&
+            arg !== targetDate &&
+            arg !== orgScope &&
+            arg !== orgScopesString &&
+            (version === undefined || arg !== version.toString()));
+        // Use batch processing if multiple orgs specified
+        if (orgScopes && orgScopes.length > 0) {
+            console.log(`🎯 Propagating values for all parent KPIs (Batch mode)`);
+            console.log(`   Mode: ${forceRecalculate ? 'Force recalculate ALL' : 'Only missing values'}`);
+            console.log(`   Date: ${targetDate || 'today'}`);
+            console.log(`   Orgs: ${orgScopes.length} organizations`);
+            console.log(`   Version: ${version || 'latest'}`);
+            await propagateParentKpiValuesBatch(orgScopes, specificKpiName, forceRecalculate, targetDate, version);
+        }
+        else if (specificKpiName) {
             console.log(`🎯 Propagating values for specific KPI: ${specificKpiName}`);
             console.log(`   Mode: ${forceRecalculate ? 'Force recalculate ALL' : 'Only missing values'}`);
             console.log(`   Date: ${targetDate || 'today'}`);