cloud-cost-cli 0.1.0

package/dist/src/providers/aws/ec2.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeEC2Instances = analyzeEC2Instances;
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+const dayjs_1 = __importDefault(require("dayjs"));
+async function analyzeEC2Instances(client) {
+    const ec2Client = client.getEC2Client();
+    const cloudwatchClient = client.getCloudWatchClient();
+    const result = await ec2Client.send(new client_ec2_1.DescribeInstancesCommand({
+        Filters: [{ Name: 'instance-state-name', Values: ['running'] }],
+    }));
+    const instances = [];
+    for (const reservation of result.Reservations || []) {
+        instances.push(...(reservation.Instances || []));
+    }
+    const opportunities = [];
+    for (const instance of instances) {
+        if (!instance.InstanceId || !instance.InstanceType)
+            continue;
+        // Get average CPU over last 30 days
+        const avgCpu = await getAvgCPU(cloudwatchClient, instance.InstanceId, 30);
+        if (avgCpu < 5) {
+            const monthlyCost = (0, cost_estimator_1.getEC2MonthlyCost)(instance.InstanceType);
+            opportunities.push({
+                id: `ec2-idle-${instance.InstanceId}`,
+                provider: 'aws',
+                resourceType: 'ec2',
+                resourceId: instance.InstanceId,
+                resourceName: instance.Tags?.find((t) => t.Key === 'Name')?.Value,
+                category: 'idle',
+                currentCost: monthlyCost,
+                estimatedSavings: monthlyCost,
+                confidence: 'high',
+                recommendation: `Stop instance or downsize to t3.small (avg CPU: ${avgCpu.toFixed(1)}%)`,
+                metadata: {
+                    instanceType: instance.InstanceType,
+                    avgCpu,
+                    state: instance.State?.Name,
+                },
+                detectedAt: new Date(),
+            });
+        }
+    }
+    return opportunities;
+}
+async function getAvgCPU(cloudwatchClient, instanceId, days) {
+    const endTime = new Date();
+    const startTime = (0, dayjs_1.default)(endTime).subtract(days, 'day').toDate();
+    try {
+        const result = await cloudwatchClient.send(new client_cloudwatch_1.GetMetricStatisticsCommand({
+            Namespace: 'AWS/EC2',
+            MetricName: 'CPUUtilization',
+            Dimensions: [{ Name: 'InstanceId', Value: instanceId }],
+            StartTime: startTime,
+            EndTime: endTime,
+            Period: 86400, // 1 day
+            Statistics: [client_cloudwatch_1.Statistic.Average],
+        }));
+        if (!result.Datapoints || result.Datapoints.length === 0) {
+            return 0;
+        }
+        const avg = result.Datapoints.reduce((sum, dp) => sum + (dp.Average || 0), 0) /
+            result.Datapoints.length;
+        return avg;
+    }
+    catch (error) {
+        // CloudWatch metrics may not be available for all instances
+        return 0;
+    }
+}

package/dist/src/providers/aws/eip.d.ts

@@ -0,0 +1,3 @@
+import { AWSClient } from './client';
+import { SavingsOpportunity } from '../../types';
+export declare function analyzeElasticIPs(client: AWSClient): Promise<SavingsOpportunity[]>;

package/dist/src/providers/aws/eip.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeElasticIPs = analyzeElasticIPs;
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+async function analyzeElasticIPs(client) {
+    const ec2Client = client.getEC2Client();
+    const result = await ec2Client.send(new client_ec2_1.DescribeAddressesCommand({}));
+    const addresses = result.Addresses || [];
+    const opportunities = [];
+    for (const address of addresses) {
+        if (!address.PublicIp)
+            continue;
+        // Check if EIP is not associated with a running instance
+        if (!address.InstanceId || !address.AssociationId) {
+            const monthlyCost = (0, cost_estimator_1.getEIPMonthlyCost)();
+            opportunities.push({
+                id: `eip-unattached-${address.AllocationId || address.PublicIp}`,
+                provider: 'aws',
+                resourceType: 'eip',
+                resourceId: address.AllocationId || address.PublicIp,
+                resourceName: address.PublicIp,
+                category: 'unused',
+                currentCost: monthlyCost,
+                estimatedSavings: monthlyCost,
+                confidence: 'high',
+                recommendation: `Release unattached Elastic IP`,
+                metadata: {
+                    publicIp: address.PublicIp,
+                    allocationId: address.AllocationId,
+                    domain: address.Domain,
+                },
+                detectedAt: new Date(),
+            });
+        }
+    }
+    return opportunities;
+}

package/dist/src/providers/aws/elb.d.ts

@@ -0,0 +1,3 @@
+import { AWSClient } from './client';
+import { SavingsOpportunity } from '../../types';
+export declare function analyzeELBs(client: AWSClient): Promise<SavingsOpportunity[]>;

package/dist/src/providers/aws/elb.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeELBs = analyzeELBs;
+const client_elastic_load_balancing_v2_1 = require("@aws-sdk/client-elastic-load-balancing-v2");
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+async function analyzeELBs(client) {
+    const elbClient = client.getELBClient();
+    const result = await elbClient.send(new client_elastic_load_balancing_v2_1.DescribeLoadBalancersCommand({}));
+    const loadBalancers = result.LoadBalancers || [];
+    const opportunities = [];
+    for (const lb of loadBalancers) {
+        if (!lb.LoadBalancerArn || !lb.LoadBalancerName)
+            continue;
+        // Check if load balancer has active targets
+        const hasActiveTargets = await checkActiveTargets(elbClient, lb.LoadBalancerArn);
+        if (!hasActiveTargets) {
+            const lbType = lb.Type === 'application' ? 'alb' : lb.Type === 'network' ? 'nlb' : 'alb';
+            const monthlyCost = (0, cost_estimator_1.getELBMonthlyCost)(lbType);
+            opportunities.push({
+                id: `elb-unused-${lb.LoadBalancerName}`,
+                provider: 'aws',
+                resourceType: 'elb',
+                resourceId: lb.LoadBalancerArn,
+                resourceName: lb.LoadBalancerName,
+                category: 'unused',
+                currentCost: monthlyCost,
+                estimatedSavings: monthlyCost,
+                confidence: 'high',
+                recommendation: `Delete unused load balancer (no active targets)`,
+                metadata: {
+                    loadBalancerName: lb.LoadBalancerName,
+                    type: lb.Type,
+                    scheme: lb.Scheme,
+                    createdTime: lb.CreatedTime,
+                },
+                detectedAt: new Date(),
+            });
+        }
+    }
+    return opportunities;
+}
+async function checkActiveTargets(elbClient, loadBalancerArn) {
+    try {
+        // Get target groups for this load balancer
+        const tgResult = await elbClient.send(new client_elastic_load_balancing_v2_1.DescribeTargetGroupsCommand({ LoadBalancerArn: loadBalancerArn }));
+        const targetGroups = tgResult.TargetGroups || [];
+        if (targetGroups.length === 0) {
+            return false; // No target groups = unused
+        }
+        // Check if any target group has healthy targets
+        for (const tg of targetGroups) {
+            if (!tg.TargetGroupArn)
+                continue;
+            const healthResult = await elbClient.send(new client_elastic_load_balancing_v2_1.DescribeTargetHealthCommand({ TargetGroupArn: tg.TargetGroupArn }));
+            const healthyTargets = (healthResult.TargetHealthDescriptions || []).filter((t) => t.TargetHealth?.State === 'healthy');
+            if (healthyTargets.length > 0) {
+                return true; // Has at least one healthy target
+            }
+        }
+        return false; // No healthy targets found
+    }
+    catch (error) {
+        // If we can't determine, assume it's in use (conservative)
+        return true;
+    }
+}

package/dist/src/providers/aws/rds.d.ts

@@ -0,0 +1,3 @@
+import { AWSClient } from './client';
+import { SavingsOpportunity } from '../../types';
+export declare function analyzeRDSInstances(client: AWSClient): Promise<SavingsOpportunity[]>;

package/dist/src/providers/aws/rds.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeRDSInstances = analyzeRDSInstances;
+const client_rds_1 = require("@aws-sdk/client-rds");
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+const dayjs_1 = __importDefault(require("dayjs"));
+async function analyzeRDSInstances(client) {
+    const rdsClient = client.getRDSClient();
+    const cloudwatchClient = client.getCloudWatchClient();
+    const result = await rdsClient.send(new client_rds_1.DescribeDBInstancesCommand({}));
+    const instances = result.DBInstances || [];
+    const opportunities = [];
+    for (const instance of instances) {
+        if (!instance.DBInstanceIdentifier || !instance.DBInstanceClass)
+            continue;
+        // Get average CPU and connections over last 30 days
+        const avgCpu = await getAvgMetric(cloudwatchClient, instance.DBInstanceIdentifier, 'CPUUtilization', 30);
+        const avgConnections = await getAvgMetric(cloudwatchClient, instance.DBInstanceIdentifier, 'DatabaseConnections', 30);
+        // Detect oversized: low CPU (<20%) or low connections
+        if (avgCpu < 20 && avgCpu > 0) {
+            const currentCost = (0, cost_estimator_1.getRDSMonthlyCost)(instance.DBInstanceClass);
+            // Estimate smaller instance class (rough heuristic)
+            const smallerClass = getSmallerInstanceClass(instance.DBInstanceClass);
+            const proposedCost = smallerClass ? (0, cost_estimator_1.getRDSMonthlyCost)(smallerClass) : 0;
+            const savings = currentCost - proposedCost;
+            if (savings > 0) {
+                opportunities.push({
+                    id: `rds-oversized-${instance.DBInstanceIdentifier}`,
+                    provider: 'aws',
+                    resourceType: 'rds',
+                    resourceId: instance.DBInstanceIdentifier,
+                    resourceName: instance.DBInstanceIdentifier,
+                    category: 'oversized',
+                    currentCost,
+                    estimatedSavings: savings,
+                    confidence: 'medium',
+                    recommendation: `Downsize to ${smallerClass || 'smaller instance'} (avg CPU: ${avgCpu.toFixed(1)}%, avg connections: ${avgConnections.toFixed(0)})`,
+                    metadata: {
+                        instanceClass: instance.DBInstanceClass,
+                        avgCpu,
+                        avgConnections,
+                        engine: instance.Engine,
+                    },
+                    detectedAt: new Date(),
+                });
+            }
+        }
+    }
+    return opportunities;
+}
+async function getAvgMetric(cloudwatchClient, dbInstanceId, metricName, days) {
+    const endTime = new Date();
+    const startTime = (0, dayjs_1.default)(endTime).subtract(days, 'day').toDate();
+    try {
+        const result = await cloudwatchClient.send(new client_cloudwatch_1.GetMetricStatisticsCommand({
+            Namespace: 'AWS/RDS',
+            MetricName: metricName,
+            Dimensions: [{ Name: 'DBInstanceIdentifier', Value: dbInstanceId }],
+            StartTime: startTime,
+            EndTime: endTime,
+            Period: 86400, // 1 day
+            Statistics: [client_cloudwatch_1.Statistic.Average],
+        }));
+        if (!result.Datapoints || result.Datapoints.length === 0) {
+            return 0;
+        }
+        const avg = result.Datapoints.reduce((sum, dp) => sum + (dp.Average || 0), 0) /
+            result.Datapoints.length;
+        return avg;
+    }
+    catch (error) {
+        return 0;
+    }
+}
+function getSmallerInstanceClass(currentClass) {
+    // Simple downsize heuristic: xlarge -> large, large -> medium, etc.
+    const downsizeMap = {
+        'db.t3.large': 'db.t3.medium',
+        'db.t3.xlarge': 'db.t3.large',
+        'db.m5.large': 'db.t3.large',
+        'db.m5.xlarge': 'db.m5.large',
+        'db.m5.2xlarge': 'db.m5.xlarge',
+        'db.r5.large': 'db.t3.large',
+        'db.r5.xlarge': 'db.r5.large',
+        'db.r5.2xlarge': 'db.r5.xlarge',
+    };
+    return downsizeMap[currentClass] || null;
+}

package/dist/src/providers/aws/s3.d.ts

@@ -0,0 +1,3 @@
+import { AWSClient } from './client';
+import { SavingsOpportunity } from '../../types';
+export declare function analyzeS3Buckets(client: AWSClient): Promise<SavingsOpportunity[]>;

package/dist/src/providers/aws/s3.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeS3Buckets = analyzeS3Buckets;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+async function analyzeS3Buckets(client) {
+    const s3Client = client.getS3Client();
+    const result = await s3Client.send(new client_s3_1.ListBucketsCommand({}));
+    const buckets = result.Buckets || [];
+    const opportunities = [];
+    for (const bucket of buckets) {
+        if (!bucket.Name)
+            continue;
+        try {
+            // Check if bucket has lifecycle policy
+            await s3Client.send(new client_s3_1.GetBucketLifecycleConfigurationCommand({ Bucket: bucket.Name }));
+            // If we get here, lifecycle exists — skip this bucket
+        }
+        catch (error) {
+            // NoSuchLifecycleConfiguration means no lifecycle policy
+            if (error.name === 'NoSuchLifecycleConfiguration') {
+                // Estimate bucket size (we can't get exact size without CloudWatch or S3 Storage Lens)
+                // For MVP, assume buckets without lifecycle are worth flagging
+                // In production, integrate with CloudWatch GetMetricStatistics for BucketSizeBytes
+                const estimatedSizeGB = 100; // Placeholder: assume 100 GB for flagged buckets
+                const currentCost = (0, cost_estimator_1.getS3MonthlyCost)(estimatedSizeGB, 'standard');
+                const glacierCost = (0, cost_estimator_1.getS3MonthlyCost)(estimatedSizeGB * 0.5, 'glacier'); // Assume 50% can move to Glacier
+                const savings = currentCost - glacierCost - (estimatedSizeGB * 0.5 * 0.023); // Remaining in standard
+                if (savings > 5) {
+                    // Only flag if savings > $5/month
+                    opportunities.push({
+                        id: `s3-no-lifecycle-${bucket.Name}`,
+                        provider: 'aws',
+                        resourceType: 's3',
+                        resourceId: bucket.Name,
+                        resourceName: bucket.Name,
+                        category: 'misconfigured',
+                        currentCost,
+                        estimatedSavings: savings,
+                        confidence: 'low',
+                        recommendation: `Enable lifecycle policy (Intelligent-Tiering or Glacier transition)`,
+                        metadata: {
+                            bucketName: bucket.Name,
+                            estimatedSizeGB,
+                            creationDate: bucket.CreationDate,
+                        },
+                        detectedAt: new Date(),
+                    });
+                }
+            }
+        }
+    }
+    return opportunities;
+}

package/dist/src/reporters/json.d.ts

@@ -0,0 +1,2 @@
+import { ScanReport } from '../types';
+export declare function renderJSON(report: ScanReport): void;

package/dist/src/reporters/json.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJSON = renderJSON;
+function renderJSON(report) {
+    console.log(JSON.stringify(report, null, 2));
+}

package/dist/src/reporters/table.d.ts

@@ -0,0 +1,2 @@
+import { ScanReport } from '../types';
+export declare function renderTable(report: ScanReport, topN?: number): void;

package/dist/src/reporters/table.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTable = renderTable;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("../utils");
+function renderTable(report, topN = 5) {
+    console.log(chalk_1.default.bold('\nCloud Cost Optimization Report'));
+    console.log(`Provider: ${report.provider} | Region: ${report.region} | Account: ${report.accountId}`);
+    console.log(`Analyzed: ${report.scanPeriod.start.toISOString().split('T')[0]} to ${report.scanPeriod.end.toISOString().split('T')[0]}\n`);
+    const opportunities = report.opportunities
+        .sort((a, b) => b.estimatedSavings - a.estimatedSavings)
+        .slice(0, topN);
+    if (opportunities.length === 0) {
+        console.log(chalk_1.default.green('✓ No cost optimization opportunities found!'));
+        return;
+    }
+    console.log(chalk_1.default.bold(`Top ${opportunities.length} Savings Opportunities (est. ${(0, utils_1.formatCurrency)(report.totalPotentialSavings)}/month):\n`));
+    const table = new cli_table3_1.default({
+        head: ['#', 'Type', 'Resource ID', 'Recommendation', 'Savings/mo'],
+        colWidths: [5, 10, 25, 50, 15],
+        style: {
+            head: ['cyan'],
+        },
+    });
+    opportunities.forEach((opp, index) => {
+        table.push([
+            (index + 1).toString(),
+            opp.resourceType.toUpperCase(),
+            opp.resourceId,
+            opp.recommendation,
+            chalk_1.default.green((0, utils_1.formatCurrency)(opp.estimatedSavings)),
+        ]);
+    });
+    console.log(table.toString());
+    console.log(chalk_1.default.bold(`\nTotal potential savings: ${chalk_1.default.green((0, utils_1.formatCurrency)(report.totalPotentialSavings))}/month (${chalk_1.default.green((0, utils_1.formatCurrency)(report.totalPotentialSavings * 12))}/year)`));
+    console.log(`\nSummary: ${report.summary.totalResources} resources analyzed | ${report.summary.idleResources} idle | ${report.summary.oversizedResources} oversized | ${report.summary.unusedResources} unused\n`);
+}

package/dist/src/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './opportunity';
+export * from './provider';

package/dist/src/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./opportunity"), exports);
+__exportStar(require("./provider"), exports);

package/dist/src/types/opportunity.d.ts

@@ -0,0 +1,31 @@
+export interface SavingsOpportunity {
+    id: string;
+    provider: 'aws' | 'gcp' | 'azure';
+    resourceType: string;
+    resourceId: string;
+    resourceName?: string;
+    category: 'idle' | 'oversized' | 'unused' | 'misconfigured';
+    currentCost: number;
+    estimatedSavings: number;
+    confidence: 'high' | 'medium' | 'low';
+    recommendation: string;
+    metadata: Record<string, any>;
+    detectedAt: Date;
+}
+export interface ScanReport {
+    provider: string;
+    accountId: string;
+    region: string;
+    scanPeriod: {
+        start: Date;
+        end: Date;
+    };
+    opportunities: SavingsOpportunity[];
+    totalPotentialSavings: number;
+    summary: {
+        totalResources: number;
+        idleResources: number;
+        oversizedResources: number;
+        unusedResources: number;
+    };
+}

package/dist/src/types/opportunity.js

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

package/dist/src/types/provider.d.ts

@@ -0,0 +1,15 @@
+import { ScanReport } from './opportunity';
+export interface CloudProvider {
+    name: string;
+    scan(options: ScanOptions): Promise<ScanReport>;
+}
+export interface ScanOptions {
+    region?: string;
+    profile?: string;
+    startDate?: Date;
+    endDate?: Date;
+    thresholds?: {
+        idleCpuPercent?: number;
+        minAgeDays?: number;
+    };
+}

package/dist/src/types/provider.js

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

package/dist/src/utils/formatter.d.ts

@@ -0,0 +1,3 @@
+export declare function formatCurrency(amount: number): string;
+export declare function formatDate(date: Date): string;
+export declare function daysSince(date: Date): number;

package/dist/src/utils/formatter.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.daysSince = daysSince;
+function formatCurrency(amount) {
+    return `$${amount.toFixed(2)}`;
+}
+function formatDate(date) {
+    return date.toISOString().split('T')[0];
+}
+function daysSince(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    return Math.floor(diff / (1000 * 60 * 60 * 24));
+}

package/dist/src/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logger';
+export * from './formatter';

package/dist/src/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logger"), exports);
+__exportStar(require("./formatter"), exports);

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,6 @@
+export declare function log(message: string): void;
+export declare function success(message: string): void;
+export declare function error(message: string): void;
+export declare function warn(message: string): void;
+export declare function info(message: string): void;
+export declare function progress(message: string): void;

package/dist/src/utils/logger.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+exports.success = success;
+exports.error = error;
+exports.warn = warn;
+exports.info = info;
+exports.progress = progress;
+const chalk_1 = __importDefault(require("chalk"));
+function log(message) {
+    console.log(message);
+}
+function success(message) {
+    console.log(chalk_1.default.green('✓'), message);
+}
+function error(message) {
+    console.error(chalk_1.default.red('✗'), message);
+}
+function warn(message) {
+    console.warn(chalk_1.default.yellow('⚠'), message);
+}
+function info(message) {
+    console.log(chalk_1.default.blue('ℹ'), message);
+}
+function progress(message) {
+    process.stdout.write(chalk_1.default.gray(message));
+}