gitgreen 0.1.0

package/dist/lib/carbon/carbon-calculator.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonCalculator = void 0;
+const Spline = require('cubic-spline');
+class CarbonCalculator {
+    constructor(powerProfileRepository, zoneMapper, intensityProvider) {
+        this.powerProfileRepository = powerProfileRepository;
+        this.zoneMapper = zoneMapper;
+        this.intensityProvider = intensityProvider;
+    }
+    interpolatePower(profile, utilization) {
+        const sorted = profile.slice().sort((a, b) => a.percentage - b.percentage);
+        const exact = sorted.find(point => point.percentage === utilization);
+        if (exact)
+            return exact.watts;
+        const percentages = sorted.map(p => p.percentage);
+        const watts = sorted.map(p => p.watts);
+        const spline = new Spline(percentages, watts);
+        return spline.at(utilization);
+    }
+    parseTimestamp(ts) {
+        return new Date(ts).getTime() / 1000;
+    }
+    async calculate(job) {
+        const machineProfile = await this.powerProfileRepository.getMachineProfile(job.provider, job.machineType);
+        if (!machineProfile) {
+            throw new Error(`No machine profile found for ${job.machineType} on ${job.provider}`);
+        }
+        const cpuProfile = await this.powerProfileRepository.getCpuPowerProfile(job.provider, job.machineType);
+        if (!cpuProfile || cpuProfile.length === 0) {
+            throw new Error(`No CPU power profile for ${job.machineType}`);
+        }
+        const { zone, pue } = this.zoneMapper.resolve(job.provider, job.region);
+        const carbonIntensity = await this.intensityProvider.getCarbonIntensity(zone);
+        // Sort timeseries by timestamp
+        const cpuSorted = [...job.cpuTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
+        const ramUsedSorted = [...job.ramUsedTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
+        const ramSizeSorted = [...job.ramSizeTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
+        // GCP reports metrics every 60 seconds
+        const GCP_INTERVAL_SECONDS = 60;
+        // Integrate CPU energy over timeseries
+        let cpuEnergyKwh = 0;
+        for (let i = 0; i < cpuSorted.length; i++) {
+            const cpuPercent = cpuSorted[i].value * 100; // GCP returns 0-1, convert to 0-100
+            const powerWatts = this.interpolatePower(cpuProfile, cpuPercent);
+            // Calculate interval from timestamps, or use GCP interval for single point
+            let intervalSeconds;
+            if (cpuSorted.length === 1) {
+                intervalSeconds = GCP_INTERVAL_SECONDS;
+            }
+            else if (i < cpuSorted.length - 1) {
+                intervalSeconds = this.parseTimestamp(cpuSorted[i + 1].timestamp) - this.parseTimestamp(cpuSorted[i].timestamp);
+            }
+            else {
+                intervalSeconds = this.parseTimestamp(cpuSorted[i].timestamp) - this.parseTimestamp(cpuSorted[i - 1].timestamp);
+            }
+            cpuEnergyKwh += (powerWatts / 1000) * (intervalSeconds / 3600);
+        }
+        // Integrate RAM energy over timeseries
+        let ramEnergyKwh = 0;
+        const RAM_WATTS_PER_GB = 0.5;
+        for (let i = 0; i < ramUsedSorted.length; i++) {
+            const ramUsedBytes = ramUsedSorted[i].value;
+            const ramUsedGb = ramUsedBytes / (1024 * 1024 * 1024);
+            const powerWatts = ramUsedGb * RAM_WATTS_PER_GB;
+            let intervalSeconds;
+            if (ramUsedSorted.length === 1) {
+                intervalSeconds = GCP_INTERVAL_SECONDS;
+            }
+            else if (i < ramUsedSorted.length - 1) {
+                intervalSeconds = this.parseTimestamp(ramUsedSorted[i + 1].timestamp) - this.parseTimestamp(ramUsedSorted[i].timestamp);
+            }
+            else {
+                intervalSeconds = this.parseTimestamp(ramUsedSorted[i].timestamp) - this.parseTimestamp(ramUsedSorted[i - 1].timestamp);
+            }
+            ramEnergyKwh += (powerWatts / 1000) * (intervalSeconds / 3600);
+        }
+        // Calculate total runtime from timeseries
+        const firstTs = Math.min(cpuSorted.length > 0 ? this.parseTimestamp(cpuSorted[0].timestamp) : Infinity, ramUsedSorted.length > 0 ? this.parseTimestamp(ramUsedSorted[0].timestamp) : Infinity);
+        const lastTs = Math.max(cpuSorted.length > 0 ? this.parseTimestamp(cpuSorted[cpuSorted.length - 1].timestamp) : 0, ramUsedSorted.length > 0 ? this.parseTimestamp(ramUsedSorted[ramUsedSorted.length - 1].timestamp) : 0);
+        // If single point, use GCP interval; otherwise use actual span
+        const runtimeSeconds = lastTs === firstTs ? GCP_INTERVAL_SECONDS : (lastTs - firstTs);
+        const runtimeHours = runtimeSeconds / 3600;
+        // Calculate emissions
+        const cpuEmissions = cpuEnergyKwh * pue * carbonIntensity;
+        const ramEmissions = ramEnergyKwh * pue * carbonIntensity;
+        const scope3Emissions = (machineProfile.scope3EmissionsHourly || 0) * runtimeHours;
+        const totalEmissions = cpuEmissions + ramEmissions + scope3Emissions;
+        return {
+            totalEmissions,
+            cpuEmissions,
+            ramEmissions,
+            scope3Emissions,
+            cpuEnergyKwh,
+            ramEnergyKwh,
+            runtimeHours,
+            pue,
+            carbonIntensity,
+            provider: job.provider,
+            machineType: job.machineType,
+            region: job.region
+        };
+    }
+}
+exports.CarbonCalculator = CarbonCalculator;

package/dist/lib/carbon/intensity-provider.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntensityProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+class IntensityProvider {
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async getCarbonIntensity(zone) {
+        if (!this.apiKey) {
+            throw new Error('ELECTRICITY_MAPS_API_KEY is required. Get one at https://api-portal.electricitymaps.com/');
+        }
+        const url = `${this.baseUrl.replace(/\/$/, '')}/carbon-intensity/latest`;
+        const response = await axios_1.default.get(url, {
+            params: { zone },
+            headers: { 'auth-token': this.apiKey }
+        });
+        const intensity = response.data.carbonIntensity;
+        if (typeof intensity !== 'number' || intensity < 0) {
+            throw new Error(`Invalid carbon intensity response for ${zone}`);
+        }
+        return intensity;
+    }
+}
+exports.IntensityProvider = IntensityProvider;

package/dist/lib/carbon/power-profile-repository.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerProfileRepository = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class PowerProfileRepository {
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.gcpMachines = null;
+        this.awsMachines = null;
+        this.cpuProfiles = null;
+    }
+    loadJsonFile(filename) {
+        const filePath = path_1.default.join(this.dataDir, filename);
+        const raw = fs_1.default.readFileSync(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    loadMachineData(provider) {
+        if (provider === 'gcp') {
+            if (!this.gcpMachines) {
+                this.gcpMachines = this.loadJsonFile('gcp_machine_power_profiles.json');
+            }
+            return this.gcpMachines;
+        }
+        if (!this.awsMachines) {
+            this.awsMachines = this.loadJsonFile('aws_machine_power_profiles.json');
+        }
+        return this.awsMachines;
+    }
+    loadCpuProfiles() {
+        if (!this.cpuProfiles) {
+            this.cpuProfiles = this.loadJsonFile('cpu_power_profiles.json');
+        }
+        return this.cpuProfiles;
+    }
+    normalizeNumber(value) {
+        if (typeof value === 'number')
+            return value;
+        if (!value)
+            return 0;
+        const parsed = parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    normalizePowerPoints(points) {
+        return points.map(p => ({
+            percentage: Number(p.percentage),
+            watts: Number(p.watts)
+        })).sort((a, b) => a.percentage - b.percentage);
+    }
+    async getMachineProfile(provider, machineType) {
+        const machines = this.loadMachineData(provider);
+        const raw = machines[machineType];
+        if (!raw)
+            return null;
+        const powerProfile = raw.cpu_power_profile ? this.normalizePowerPoints(raw.cpu_power_profile) : [];
+        return {
+            machineType,
+            vcpus: this.normalizeNumber(raw.vcpus),
+            memoryGb: this.normalizeNumber(raw.memory_gb),
+            platformCpu: raw.platform_cpu,
+            matchedCpuProfile: raw.matched_cpu_profile,
+            cpuPowerProfile: powerProfile,
+            scope3EmissionsHourly: raw.scope3_emissions_hourly
+        };
+    }
+    async getCpuPowerProfile(provider, machineType) {
+        const profile = await this.getMachineProfile(provider, machineType);
+        if (!profile)
+            return null;
+        if (profile.cpuPowerProfile && profile.cpuPowerProfile.length > 0) {
+            return profile.cpuPowerProfile;
+        }
+        if (profile.matchedCpuProfile) {
+            const cpuProfiles = this.loadCpuProfiles();
+            const rawCpu = cpuProfiles[profile.matchedCpuProfile];
+            if (rawCpu) {
+                return this.normalizePowerPoints(rawCpu.power_profile);
+            }
+        }
+        return null;
+    }
+    listMachines(provider) {
+        const machines = this.loadMachineData(provider);
+        return Object.keys(machines).sort();
+    }
+}
+exports.PowerProfileRepository = PowerProfileRepository;

package/dist/lib/carbon/zone-mapper.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZoneMapper = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class ZoneMapper {
+    constructor(dataDir, fallbackPue) {
+        this.dataDir = dataDir;
+        this.fallbackPue = fallbackPue;
+        this.runtimePueData = null;
+        this.gcpZoneMapping = {
+            'us-central1': 'US-CENT-SWPP',
+            'us-east1': 'US-NE-ISNE',
+            'us-east4': 'US-MIDA-PJM',
+            'us-west1': 'US-CAL-CISO',
+            'us-west2': 'US-NW-PACW',
+            'us-west3': 'US-SW-AZPS',
+            'us-west4': 'US-NW-NEVP',
+            'europe-west1': 'BE',
+            'europe-west2': 'GB',
+            'europe-west3': 'DE',
+            'europe-west4': 'NL',
+            'europe-west6': 'CH',
+            'europe-north1': 'FI',
+            'asia-east1': 'TW',
+            'asia-east2': 'HK',
+            'asia-northeast1': 'JP-TK',
+            'asia-northeast2': 'JP-KN',
+            'asia-northeast3': 'KR',
+            'asia-south1': 'IN-WE',
+            'asia-southeast1': 'SG',
+            'asia-southeast2': 'ID-JW',
+            'australia-southeast1': 'AU-NSW'
+        };
+        this.awsZoneMapping = {
+            'us-east-1': { zone: 'US-NE-ISNE', pue: 1.18 },
+            'us-east-2': { zone: 'US-MIDA-PJM', pue: 1.18 },
+            'us-west-1': { zone: 'US-CAL-CISO', pue: 1.15 },
+            'us-west-2': { zone: 'US-NW-PACW', pue: 1.14 },
+            'eu-west-1': { zone: 'IE', pue: 1.18 },
+            'eu-west-2': { zone: 'GB', pue: 1.18 },
+            'eu-central-1': { zone: 'DE', pue: 1.16 },
+            'ap-northeast-1': { zone: 'JP-TK', pue: 1.2 },
+            'ap-southeast-1': { zone: 'SG', pue: 1.2 },
+            'ap-south-1': { zone: 'IN-NO', pue: 1.22 }
+        };
+    }
+    loadRuntimePueData() {
+        if (this.runtimePueData)
+            return this.runtimePueData;
+        const filePath = path_1.default.join(this.dataDir, 'runtime-pue-mappings.json');
+        if (!fs_1.default.existsSync(filePath)) {
+            return null;
+        }
+        try {
+            const raw = fs_1.default.readFileSync(filePath, 'utf8');
+            this.runtimePueData = JSON.parse(raw);
+            return this.runtimePueData;
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    normalizeRegion(region, provider) {
+        if (provider === 'gcp') {
+            if (/^[a-z]+-[a-z0-9]+[1-9]-[a-z]$/.test(region)) {
+                return region.split('-').slice(0, 2).join('-');
+            }
+            return region;
+        }
+        if (/^[a-z]+-[a-z]+-[0-9][a-z]$/.test(region)) {
+            return region.slice(0, -1);
+        }
+        return region;
+    }
+    resolve(provider, region) {
+        const normalizedRegion = this.normalizeRegion(region, provider);
+        if (provider === 'gcp') {
+            const runtime = this.loadRuntimePueData();
+            const runtimeRegion = runtime?.regions?.[normalizedRegion];
+            const runtimePue = runtimeRegion?.industryStandardPUE;
+            const runtimeZone = runtimeRegion?.zone;
+            const zone = runtimeZone && runtimeZone !== 'FALLBACK'
+                ? runtimeZone
+                : this.gcpZoneMapping[normalizedRegion];
+            if (!zone) {
+                throw new Error(`No zone mapping for GCP region ${normalizedRegion}`);
+            }
+            return {
+                zone,
+                pue: runtimePue || this.fallbackPue
+            };
+        }
+        const awsMapping = this.awsZoneMapping[normalizedRegion];
+        if (!awsMapping) {
+            throw new Error(`No zone mapping for AWS region ${normalizedRegion}`);
+        }
+        return {
+            zone: awsMapping.zone,
+            pue: awsMapping.pue || this.fallbackPue
+        };
+    }
+}
+exports.ZoneMapper = ZoneMapper;

package/dist/lib/gitlab/gitlab-client.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLabClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class GitLabClient {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    apiBase(serverUrl) {
+        const base = serverUrl || this.baseUrl;
+        return `${base.replace(/\/$/, '')}/api/v4`;
+    }
+    async postMergeRequestNote(context, body) {
+        if (!context.mergeRequestIid) {
+            return;
+        }
+        const url = `${this.apiBase(context.serverUrl)}/projects/${context.projectId}/merge_requests/${context.mergeRequestIid}/notes`;
+        await axios_1.default.post(url, { body }, {
+            headers: {
+                'JOB-TOKEN': context.jobToken
+            }
+        });
+    }
+}
+exports.GitLabClient = GitLabClient;

package/dist/lib/gitlab/report-formatter.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildJsonReport = exports.buildMarkdownReport = exports.evaluateBudget = exports.gramsToString = void 0;
+const asciichart_1 = __importDefault(require("asciichart"));
+const formatNumber = (value, decimals = 2) => Number(value).toFixed(decimals);
+const gramsToString = (grams) => {
+    if (grams >= 1000) {
+        return `${formatNumber(grams / 1000, 3)} kgCO₂e`;
+    }
+    return `${formatNumber(grams, 3)} gCO₂e`;
+};
+exports.gramsToString = gramsToString;
+const formatDuration = (hours) => {
+    const seconds = hours * 3600;
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    const minutes = seconds / 60;
+    if (minutes < 60)
+        return `${formatNumber(minutes, 1)}m`;
+    return `${formatNumber(hours, 2)}h`;
+};
+const evaluateBudget = (result, budget) => {
+    if (!budget || !budget.carbonBudgetGrams) {
+        return { budgetConfigured: false, overBudget: false };
+    }
+    return {
+        budgetConfigured: true,
+        limitGrams: budget.carbonBudgetGrams,
+        overBudget: result.totalEmissions > budget.carbonBudgetGrams
+    };
+};
+exports.evaluateBudget = evaluateBudget;
+const buildMarkdownReport = (result, job, budget) => {
+    const budgetResult = (0, exports.evaluateBudget)(result, budget);
+    const totalEnergyKwh = result.cpuEnergyKwh + result.ramEnergyKwh;
+    // Sort timeseries for charts
+    const cpuSorted = [...job.cpuTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const ramSorted = [...job.ramUsedTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const ramSizeSorted = [...job.ramSizeTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const lines = [
+        '# Carbon report',
+        '',
+        `- Cloud provider: ${result.provider.toUpperCase()}`,
+        `- Region/zone: ${result.region}`,
+        `- Machine type: ${result.machineType}`,
+        `- Runtime: ${formatDuration(result.runtimeHours)}`,
+        `- Data points: ${job.cpuTimeseries.length} CPU, ${job.ramUsedTimeseries.length} RAM`,
+        `- Total energy: ${formatNumber(totalEnergyKwh * 1000, 3)} Wh`,
+        `  - CPU: ${formatNumber(result.cpuEnergyKwh * 1000, 3)} Wh`,
+        `  - RAM: ${formatNumber(result.ramEnergyKwh * 1000, 3)} Wh`,
+        `- Total emissions: ${(0, exports.gramsToString)(result.totalEmissions)}`,
+        `  - CPU: ${(0, exports.gramsToString)(result.cpuEmissions)}`,
+        `  - RAM: ${(0, exports.gramsToString)(result.ramEmissions)}`,
+        `  - Scope 3: ${(0, exports.gramsToString)(result.scope3Emissions)}`,
+        `- Power usage effectiveness (PUE): ${formatNumber(result.pue, 2)}`,
+        `- Grid carbon intensity: ${formatNumber(result.carbonIntensity, 2)} gCO₂e/kWh`
+    ];
+    if (budgetResult.budgetConfigured && budgetResult.limitGrams) {
+        const status = budgetResult.overBudget ? 'over budget' : 'within budget';
+        lines.push(`- Budget: ${(0, exports.gramsToString)(budgetResult.limitGrams)} (${status})`);
+    }
+    // Add CPU chart (only if more than 1 point)
+    if (cpuSorted.length > 1) {
+        const cpuValues = cpuSorted.map(p => p.value * 100);
+        lines.push('', '## CPU Utilization (%)', '```', asciichart_1.default.plot(cpuValues, { height: 6 }), '```');
+    }
+    // Add RAM chart (only if more than 1 point)
+    if (ramSorted.length > 1 && ramSizeSorted.length > 0) {
+        const totalRamGb = ramSizeSorted[0].value / (1024 * 1024 * 1024);
+        const ramPercent = ramSorted.map(p => (p.value / (1024 * 1024 * 1024) / totalRamGb) * 100);
+        lines.push('', '## RAM Utilization (%)', '```', asciichart_1.default.plot(ramPercent, { height: 6 }), '```');
+    }
+    return lines.join('\n');
+};
+exports.buildMarkdownReport = buildMarkdownReport;
+const buildJsonReport = (result, job, budget) => {
+    const budgetResult = (0, exports.evaluateBudget)(result, budget);
+    return {
+        job: {
+            provider: job.provider,
+            region: job.region,
+            machineType: job.machineType,
+            cpuDataPoints: job.cpuTimeseries.length,
+            ramDataPoints: job.ramUsedTimeseries.length
+        },
+        emissions: result,
+        budget: budgetResult
+    };
+};
+exports.buildJsonReport = buildJsonReport;

package/dist/lib/telemetry/gitlab-job-loader.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLabJobLoader = void 0;
+const axios_1 = __importDefault(require("axios"));
+class GitLabJobLoader {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    apiBase(serverUrl) {
+        return `${(serverUrl || this.baseUrl).replace(/\/$/, '')}/api/v4`;
+    }
+    async fetchJob(projectId, jobId, jobToken, serverUrl) {
+        const url = `${this.apiBase(serverUrl)}/projects/${projectId}/jobs/${jobId}`;
+        const { data } = await axios_1.default.get(url, {
+            headers: { 'JOB-TOKEN': jobToken }
+        });
+        return data;
+    }
+}
+exports.GitLabJobLoader = GitLabJobLoader;

package/dist/lib/telemetry/runner-parser.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractZoneOrRegion = exports.extractMachineType = exports.extractGcpProject = exports.extractInstanceId = void 0;
+const zoneRegexGcp = /^[a-z]+-[a-z0-9]+-[a-z]$/;
+const regionRegexAws = /^[a-z]+-[a-z]+-[0-9]$/;
+const regionZoneRegexAws = /^[a-z]+-[a-z]+-[0-9][a-z]$/; // e.g., us-east-1a
+const extractInstanceId = (tags) => {
+    for (const tag of tags) {
+        const gcpMatch = tag.match(/^instance-(\d+)$/);
+        if (gcpMatch)
+            return gcpMatch[1];
+        const awsMatch = tag.match(/^i-[a-f0-9]+$/i);
+        if (awsMatch)
+            return awsMatch[0];
+    }
+    return null;
+};
+exports.extractInstanceId = extractInstanceId;
+const extractGcpProject = (tags) => {
+    for (const tag of tags) {
+        const match = tag.match(/^project-(.+)$/);
+        if (match)
+            return match[1];
+    }
+    return null;
+};
+exports.extractGcpProject = extractGcpProject;
+const extractMachineType = (tags, description) => {
+    const candidates = [...tags, description || ''];
+    for (const value of candidates) {
+        if (!value)
+            continue;
+        const awsMatch = value.match(/\b([cmrtpgidfhsvx][0-9]+[a-z]?(?:\.\d*xlarge|\.\d*large|\.metal|\.nano|\.micro|\.small|\.medium|\.xlarge))\b/i);
+        if (awsMatch)
+            return awsMatch[1];
+        const gcpMatch = value.match(/\b([a-z0-9]+-[a-z]+-[a-z0-9]+)\b/);
+        if (gcpMatch)
+            return gcpMatch[1];
+    }
+    return null;
+};
+exports.extractMachineType = extractMachineType;
+const extractZoneOrRegion = (tags, description) => {
+    const candidates = [...tags, description || ''];
+    for (const value of candidates) {
+        if (!value)
+            continue;
+        const parts = value.split(/[,\s]+/);
+        for (const part of parts) {
+            if (zoneRegexGcp.test(part)) {
+                return { zoneOrRegion: part, providerGuess: 'gcp' };
+            }
+            if (regionZoneRegexAws.test(part)) {
+                return { zoneOrRegion: part.slice(0, -1), providerGuess: 'aws' }; // strip zone letter
+            }
+            if (regionRegexAws.test(part)) {
+                return { zoneOrRegion: part, providerGuess: 'aws' };
+            }
+        }
+    }
+    return { zoneOrRegion: null };
+};
+exports.extractZoneOrRegion = extractZoneOrRegion;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "gitgreen",
+  "version": "0.1.0",
+  "description": "GitGreen CLI for carbon reporting in GitLab pipelines (GCP/AWS)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "gitgreen": "dist/cli.js",
+    "gitgreen-cli": "dist/cli.js",
+    "carbon-cli": "dist/cli.js"
+  },
+  "packageManager": "pnpm@8.15.4",
+  "license": "MIT",
+  "keywords": [
+    "carbon",
+    "sustainability",
+    "gitlab",
+    "cli",
+    "gcp",
+    "aws"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "dev": "ts-node src/cli.ts",
+    "prepare": "npm run build",
+    "test": "vitest run",
+    "stress": "bash ./scripts/stress.sh",
+    "prepublishOnly": "pnpm build && pnpm test"
+  },
+  "files": [
+    "dist",
+    "data",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aws-sdk/client-cloudwatch": "^3.525.0",
+    "@google-cloud/monitoring": "^4.1.0",
+    "asciichart": "^1.5.25",
+    "axios": "^1.9.0",
+    "commander": "^12.1.0",
+    "cubic-spline": "^3.0.3",
+    "dotenv": "^16.5.0",
+    "kleur": "^4.1.5",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "@types/prompts": "^2.4.9",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.0",
+    "vitest": "^1.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}