@dssp/dkpi 1.0.0-alpha.7 → 1.0.0-alpha.70

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

@@ -0,0 +1,786 @@
+#!/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
+ */
+async function propagateParentKpiValues(specificKpiName, forceRecalculate = false, targetDate, orgScope, version) {
+    // Set NODE_ENV if not set
+    if (!process.env.NODE_ENV) {
+        process.env.NODE_ENV = 'development';
+    }
+    // Initialize Things-Factory environment
+    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 Parent KPI Value Propagation...');
+    try {
+        // Create database connection using Things-Factory pattern
+        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');
+        // Now we can use getRepository with the registered connection
+        const { getRepository } = require('@things-factory/shell');
+        const { Kpi } = require('@things-factory/kpi');
+        const kpiRepository = getRepository(Kpi);
+        // Get KPI-Value repository
+        let kpiValueRepository;
+        try {
+            const { KpiValue } = require('@things-factory/kpi');
+            kpiValueRepository = getRepository(KpiValue);
+        }
+        catch (error) {
+            console.error('❌ KpiValue entity not found. Please ensure it exists in @things-factory/kpi');
+            return;
+        }
+        // Get Domain repository and find SYSTEM domain
+        let systemDomain;
+        try {
+            const { Domain } = require('@things-factory/shell');
+            const domainRepository = getRepository(Domain);
+            systemDomain = await domainRepository.findOne({ where: { name: 'SYSTEM' } });
+            if (!systemDomain) {
+                console.error('❌ SYSTEM domain not found');
+                return;
+            }
+        }
+        catch (error) {
+            console.error('❌ Domain entity not found:', error.message);
+            return;
+        }
+        // Get all KPIs with their hierarchy
+        let kpisQuery = kpiRepository
+            .createQueryBuilder('kpi')
+            .leftJoinAndSelect('kpi.domain', 'domain')
+            .leftJoinAndSelect('kpi.parent', 'parent')
+            .leftJoinAndSelect('kpi.children', 'children')
+            .where('domain.name = :domainName', { domainName: 'SYSTEM' });
+        if (specificKpiName) {
+            kpisQuery = kpisQuery.andWhere('kpi.name = :name', { name: specificKpiName });
+            console.log(`🎯 Processing specific KPI: ${specificKpiName}`);
+        }
+        else {
+            console.log('🎯 Processing all KPIs in hierarchy');
+        }
+        const allKpis = await kpisQuery.getMany();
+        if (allKpis.length === 0) {
+            console.log('⚠️  No KPIs found');
+            return;
+        }
+        console.log(`📊 Found ${allKpis.length} KPIs total`);
+        // Get parent KPIs (non-leaf KPIs) ordered by level (deepest first)
+        const parentKpis = allKpis.filter(kpi => !kpi.isLeaf);
+        if (parentKpis.length === 0) {
+            console.log('⚠️  No parent KPIs found');
+            return;
+        }
+        // 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 errorCount = 0;
+        // 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 }];
+        }
+        else if (orgScope) {
+            // Get all dates for specific group
+            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 }));
+        }
+        else {
+            // Get all distinct (group, valueDate) combinations
+            const combinations = await kpiValueRepository.query(`
+        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 }));
+        }
+        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}`);
+            // Process each parent KPI from deepest to shallowest for this group and date
+            for (const parentKpi of sortedParentKpis) {
+                try {
+                    console.log(`\\n📄 Processing Parent KPI: ${parentKpi.name} (Level ${parentKpi.__level || '?'}) - Group: ${currentGroup}, Date: ${valueDate}`);
+                    // Get child KPIs
+                    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) {
+                        console.log(`   ⚠️  No child KPIs found, skipping`);
+                        continue;
+                    }
+                    console.log(`   👶 Found ${childKpis.length} child KPIs`);
+                    // Get child KPI values/scores for the specific group and date
+                    const childValues = await getChildKpiValues(kpiValueRepository, childKpis, valueDate, version, currentGroup);
+                    if (childValues.length === 0) {
+                        console.log(`   ⚠️  No child KPI values found for date ${valueDate} and group ${currentGroup}, skipping`);
+                        continue;
+                    }
+                    console.log(`   📊 Found values for ${childValues.length}/${childKpis.length} child KPIs`);
+                    // 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)}`);
+                        }
+                        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 {
+                        // 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++;
+                }
+                catch (kpiError) {
+                    console.log(`   ❌ Error processing KPI ${parentKpi.name}: ${kpiError.message}`);
+                    errorCount++;
+                }
+            }
+        }
+        console.log(`\\n🎉 Parent KPI Value Propagation Complete!`);
+        console.log(`   📊 Parent KPIs processed: ${totalProcessed}`);
+        console.log(`   ✨ Values created: ${totalCreated}`);
+        console.log(`   ❌ Errors: ${errorCount}`);
+        if (errorCount > 0) {
+            console.log(`\\n⚠️  Some parent KPIs had errors. Check the logs above for details.`);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Fatal error during parent KPI value propagation:`, error);
+        throw error;
+    }
+    finally {
+        if (connection) {
+            await connection.close();
+            console.log('🔌 Database connection closed');
+        }
+    }
+}
+/**
+ * Sort KPIs by hierarchy level (deepest first for bottom-up processing)
+ */
+async function sortKpisByLevel(parentKpis, allKpis) {
+    // Calculate hierarchy level for each KPI
+    const kpiLevels = new Map();
+    function calculateLevel(kpi) {
+        if (kpiLevels.has(kpi.id)) {
+            return kpiLevels.get(kpi.id);
+        }
+        if (!kpi.parent) {
+            kpiLevels.set(kpi.id, 0);
+            return 0;
+        }
+        const parentKpi = allKpis.find(k => { var _a; return k.id === ((_a = kpi.parent) === null || _a === void 0 ? void 0 : _a.id); });
+        if (!parentKpi) {
+            kpiLevels.set(kpi.id, 1);
+            return 1;
+        }
+        const level = calculateLevel(parentKpi) + 1;
+        kpiLevels.set(kpi.id, level);
+        return level;
+    }
+    // Calculate levels for all parent KPIs
+    parentKpis.forEach(kpi => {
+        const level = calculateLevel(kpi);
+        kpi.__level = level;
+    });
+    // Sort by level (deepest first)
+    return parentKpis.sort((a, b) => (b.__level || 0) - (a.__level || 0));
+}
+/**
+ * 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);
+    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');
+    // 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 });
+    }
+    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
+ */
+function calculateWeightedAverage(childValues, childKpis) {
+    let totalWeightedValue = 0;
+    let totalWeightedScore = 0;
+    let totalWeight = 0;
+    for (const value of childValues) {
+        const childKpi = childKpis.find(kpi => kpi.id === value.kpi.id);
+        const weight = (childKpi === null || childKpi === void 0 ? void 0 : childKpi.weight) || 1;
+        totalWeightedValue += value.score * weight;
+        totalWeightedScore += value.score * weight;
+        totalWeight += weight;
+    }
+    if (totalWeight === 0) {
+        return { weightedValue: 0, weightedScore: 0 };
+    }
+    return {
+        weightedValue: totalWeightedValue / totalWeight,
+        weightedScore: totalWeightedScore / totalWeight
+    };
+}
+/**
+ * List parent KPIs and their hierarchy
+ */
+async function listParentKpiHierarchy() {
+    // Set NODE_ENV if not set
+    if (!process.env.NODE_ENV) {
+        process.env.NODE_ENV = 'development';
+    }
+    // Initialize Things-Factory environment
+    const { config } = require('@things-factory/env');
+    const ormconfig = require('@things-factory/shell/dist-server/initializers/ormconfig.js');
+    const connectionConfig = config.get('ormconfig');
+    let connection;
+    try {
+        console.log('🔌 Connecting to database...');
+        connection = await (0, typeorm_1.createConnection)(Object.assign(Object.assign(Object.assign({}, ormconfig), connectionConfig), { logging: false }));
+        const { addDataSource } = require('@things-factory/shell');
+        addDataSource('default', connection);
+        const { getRepository } = require('@things-factory/shell');
+        const { Kpi } = require('@things-factory/kpi');
+        const kpiRepository = getRepository(Kpi);
+        // Get all KPIs with hierarchy
+        const kpis = await kpiRepository
+            .createQueryBuilder('kpi')
+            .leftJoinAndSelect('kpi.domain', 'domain')
+            .leftJoinAndSelect('kpi.parent', 'parent')
+            .leftJoinAndSelect('kpi.children', 'children')
+            .where('domain.name = :domainName', { domainName: 'SYSTEM' })
+            .getMany();
+        const parentKpis = kpis.filter(kpi => !kpi.isLeaf);
+        const sortedParentKpis = await sortKpisByLevel(parentKpis, kpis);
+        console.log(`📁 Parent KPI Hierarchy (${sortedParentKpis.length} parents):\\n`);
+        if (sortedParentKpis.length === 0) {
+            console.log('   No parent KPIs found.');
+            return;
+        }
+        sortedParentKpis.forEach((kpi, index) => {
+            const level = kpi.__level || 0;
+            const indent = '  '.repeat(level);
+            const childCount = kpis.filter(k => { var _a; return ((_a = k.parent) === null || _a === void 0 ? void 0 : _a.id) === kpi.id; }).length;
+            const weight = kpi.weight || 1;
+            console.log(`   ${(index + 1).toString().padStart(2)}: ${indent}${kpi.name} (L${level}, ${childCount} children, weight: ${weight})`);
+        });
+        console.log(`\\n📈 Total: ${sortedParentKpis.length} parent KPIs`);
+    }
+    catch (error) {
+        console.error('❌ Error listing parent KPIs:', error);
+    }
+    finally {
+        if (connection) {
+            await connection.close();
+        }
+    }
+}
+/**
+ * CLI execution when called directly
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    try {
+        if (args.includes('--help') || args.includes('-h')) {
+            console.log(`
+🎯 Parent KPI Value Propagator
+
+Usage:
+  ts-node server/scripts/propagate-parent-kpi-values.ts [options] [kpiName]
+
+Options:
+  --list, -l           List parent KPIs and their hierarchy
+  --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
+
+Examples:
+  ts-node server/scripts/propagate-parent-kpi-values.ts                      # Process all parent KPIs for today
+  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;
+        }
+        if (args.includes('--list') || args.includes('-l')) {
+            await listParentKpiHierarchy();
+            return;
+        }
+        const forceRecalculate = args.includes('--force') || args.includes('-f');
+        const dateIndex = args.indexOf('--date');
+        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 &&
+            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'}`);
+            console.log(`   Org: ${orgScope || 'all'}`);
+            console.log(`   Version: ${version || 'latest'}`);
+            await propagateParentKpiValues(specificKpiName, forceRecalculate, targetDate, orgScope, version);
+        }
+        else {
+            console.log(`🎯 Propagating values for all parent KPIs`);
+            console.log(`   Mode: ${forceRecalculate ? 'Force recalculate ALL' : 'Only missing values'}`);
+            console.log(`   Date: ${targetDate || 'today'}`);
+            console.log(`   Org: ${orgScope || 'all'}`);
+            console.log(`   Version: ${version || 'latest'}`);
+            await propagateParentKpiValues(undefined, forceRecalculate, targetDate, orgScope, version);
+        }
+        console.log('\\n✨ Done!');
+    }
+    catch (error) {
+        console.error('\\n❌ Script failed:', error.message);
+        process.exit(1);
+    }
+}
+// Handle uncaught errors
+process.on('unhandledRejection', (error) => {
+    console.error('❌ Unhandled error:', error.message || error);
+    process.exit(1);
+});
+// Run if called directly
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=propagate-parent-kpi-values.js.map