@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/profile/analyzers/image-analyzer.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeImage = void 0;
+const child_process_1 = require("child_process");
+/**
+ * Analyze a Docker image for size, layers, and vulnerabilities
+ */
+async function analyzeImage(imageName) {
+    // Get image inspect data
+    let size = "Unknown";
+    let layers = 0;
+    let created = "Unknown";
+    let os = "Unknown";
+    let architecture = "Unknown";
+    try {
+        // Use double quotes for cross-platform compatibility (Windows + Unix)
+        const inspectOutput = (0, child_process_1.execSync)(`docker inspect ${imageName} --format "{{.Size}} {{.Created}} {{.Os}} {{.Architecture}}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        const parts = inspectOutput.split(" ");
+        const sizeBytes = parseInt(parts[0], 10);
+        size = formatBytes(sizeBytes);
+        created = parts[1] || "Unknown";
+        os = parts[2] || "linux";
+        architecture = parts[3] || "amd64";
+        // Get layer count - cross-platform (count lines in Node.js instead of wc -l)
+        const historyOutput = (0, child_process_1.execSync)(`docker history ${imageName} --format "{{.ID}}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        layers = historyOutput.split("\n").filter((line) => line.trim()).length;
+    }
+    catch (error) {
+        // Docker command failed, image might not exist or Docker not running
+        throw new Error(`Failed to inspect image: ${imageName}`);
+    }
+    // Try to scan for vulnerabilities using Trivy if available
+    const vulnerabilities = [];
+    try {
+        // Check if Trivy is available
+        (0, child_process_1.execSync)("trivy --version", { stdio: ["pipe", "pipe", "pipe"] });
+        // Run Trivy scan
+        const trivyOutput = (0, child_process_1.execSync)(`trivy image --format json --severity HIGH,CRITICAL ${imageName}`, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            maxBuffer: 50 * 1024 * 1024,
+        });
+        const trivyResult = JSON.parse(trivyOutput);
+        if (trivyResult.Results) {
+            for (const result of trivyResult.Results) {
+                if (result.Vulnerabilities) {
+                    for (const vuln of result.Vulnerabilities) {
+                        vulnerabilities.push({
+                            id: vuln.VulnerabilityID,
+                            severity: vuln.Severity?.toLowerCase() || "unknown",
+                            description: vuln.Title ||
+                                vuln.Description ||
+                                "No description",
+                            package: vuln.PkgName,
+                            fixedVersion: vuln.FixedVersion,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Trivy not available or scan failed, skip vulnerability scanning
+    }
+    return {
+        size,
+        layers,
+        created,
+        os,
+        architecture,
+        vulnerabilities,
+    };
+}
+exports.analyzeImage = analyzeImage;
+/**
+ * Format bytes to human readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}

package/bin/profile/cli.d.ts

@@ -0,0 +1,4 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = {};
+declare const profileCommand: () => CommandModule<CommandModuleArgs, any>;
+export { profileCommand };

package/bin/profile/cli.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileCommand = void 0;
+const form_1 = require("./form");
+const profileCommand = () => {
+    return {
+        command: "profile <action> [target]",
+        describe: "Analyze and optimize container configurations.",
+        aliases: ["prof", "analyze"],
+        builder: (yargs) => {
+            yargs.positional("action", {
+                choices: ["container", "image", "optimize", "report"],
+                describe: "Action to perform",
+                type: "string",
+                demandOption: true,
+            });
+            yargs.positional("target", {
+                describe: "Target to analyze (Dockerfile path or image name)",
+                type: "string",
+            });
+            yargs.option("dockerfile", {
+                describe: "Path to Dockerfile",
+                type: "string",
+                alias: "f",
+                default: "Dockerfile",
+            });
+            yargs.option("format", {
+                choices: ["text", "json", "html"],
+                describe: "Output format",
+                type: "string",
+                default: "text",
+            });
+            yargs.option("severity", {
+                choices: ["low", "medium", "high", "critical"],
+                describe: "Minimum severity to report",
+                type: "string",
+                default: "low",
+            });
+            yargs.option("auto-fix", {
+                describe: "Automatically apply safe optimizations",
+                type: "boolean",
+                default: false,
+            });
+            yargs.option("output", {
+                describe: "Output file for report",
+                type: "string",
+                alias: "o",
+            });
+            yargs.option("include-security", {
+                describe: "Include security vulnerability scanning",
+                type: "boolean",
+                default: true,
+            });
+            yargs.option("include-size", {
+                describe: "Include size analysis",
+                type: "boolean",
+                default: true,
+            });
+            return yargs;
+        },
+        handler: async (argv) => {
+            const { action, target, dockerfile, format, severity, autoFix, output, includeSecurity, includeSize, } = argv;
+            const options = {
+                target: target,
+                dockerfile,
+                format: format,
+                severity: severity,
+                autoFix,
+                output,
+                includeSecurity,
+                includeSize,
+            };
+            switch (action) {
+                case "container":
+                    await (0, form_1.profileContainer)(options);
+                    break;
+                case "image":
+                    await (0, form_1.profileImage)(options);
+                    break;
+                case "optimize":
+                    await (0, form_1.optimizeContainer)(options);
+                    break;
+                case "report":
+                    await (0, form_1.showProfileReport)(options);
+                    break;
+                default:
+                    console.log(`Unknown action: ${action}`);
+            }
+        },
+    };
+};
+exports.profileCommand = profileCommand;

package/bin/profile/form.d.ts

@@ -0,0 +1,56 @@
+export interface ProfileOptions {
+    target?: string;
+    dockerfile: string;
+    format: "text" | "json" | "html";
+    severity: "low" | "medium" | "high" | "critical";
+    autoFix: boolean;
+    output?: string;
+    includeSecurity: boolean;
+    includeSize: boolean;
+}
+export interface ProfileResult {
+    score: number;
+    issues: Issue[];
+    recommendations: Recommendation[];
+    metrics: Metrics;
+}
+export interface Issue {
+    id: string;
+    severity: "low" | "medium" | "high" | "critical";
+    category: "security" | "size" | "performance" | "best-practice";
+    message: string;
+    line?: number;
+    fix?: string;
+}
+export interface Recommendation {
+    priority: "low" | "medium" | "high";
+    category: string;
+    title: string;
+    description: string;
+    impact: string;
+}
+export interface Metrics {
+    estimatedSize?: string;
+    layers?: number;
+    baseImage?: string;
+    nodeVersion?: string;
+    hasMultiStage?: boolean;
+    hasHealthCheck?: boolean;
+    hasNonRootUser?: boolean;
+}
+/**
+ * Profile a Dockerfile for issues and recommendations
+ */
+export declare function profileContainer(options: ProfileOptions): Promise<void>;
+/**
+ * Profile a built Docker image
+ */
+export declare function profileImage(options: ProfileOptions): Promise<void>;
+/**
+ * Generate and optionally apply optimizations
+ */
+export declare function optimizeContainer(options: ProfileOptions): Promise<void>;
+/**
+ * Show a comprehensive profile report
+ */
+export declare function showProfileReport(options: ProfileOptions): Promise<void>;

package/bin/profile/form.js

@@ -0,0 +1,400 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showProfileReport = exports.optimizeContainer = exports.profileImage = exports.profileContainer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const dockerfile_analyzer_1 = require("./analyzers/dockerfile-analyzer");
+const image_analyzer_1 = require("./analyzers/image-analyzer");
+const optimizers_1 = require("./optimizers");
+/**
+ * Profile a Dockerfile for issues and recommendations
+ */
+async function profileContainer(options) {
+    console.log(chalk_1.default.cyan("\n🔍 ExpressoTS Container Profiler\n"));
+    const cwd = process.cwd();
+    const dockerfilePath = path_1.default.join(cwd, options.dockerfile);
+    if (!fs_1.default.existsSync(dockerfilePath)) {
+        console.log(chalk_1.default.red(`Error: Dockerfile not found at ${dockerfilePath}`));
+        console.log(chalk_1.default.gray("Run 'expressots containerize' to generate a Dockerfile first."));
+        return;
+    }
+    console.log(chalk_1.default.yellow(`📄 Analyzing ${options.dockerfile}...\n`));
+    const analysis = await (0, dockerfile_analyzer_1.analyzeDockerfile)(dockerfilePath);
+    const result = generateProfileResult(analysis, options);
+    outputResult(result, options);
+}
+exports.profileContainer = profileContainer;
+/**
+ * Profile a built Docker image
+ */
+async function profileImage(options) {
+    console.log(chalk_1.default.cyan("\n🔍 ExpressoTS Image Profiler\n"));
+    if (!options.target) {
+        console.log(chalk_1.default.red("Error: Please specify an image name."));
+        console.log(chalk_1.default.gray("Usage: expressots profile image <image-name>"));
+        return;
+    }
+    console.log(chalk_1.default.yellow(`🐳 Analyzing image: ${options.target}...\n`));
+    try {
+        const analysis = await (0, image_analyzer_1.analyzeImage)(options.target);
+        console.log(chalk_1.default.bold("Image Analysis:"));
+        console.log(`  Size: ${analysis.size}`);
+        console.log(`  Layers: ${analysis.layers}`);
+        console.log(`  Created: ${analysis.created}`);
+        console.log(`  OS/Arch: ${analysis.os}/${analysis.architecture}`);
+        if (analysis.vulnerabilities && analysis.vulnerabilities.length > 0) {
+            console.log(chalk_1.default.bold("\nVulnerabilities:"));
+            for (const vuln of analysis.vulnerabilities) {
+                const color = vuln.severity === "critical"
+                    ? chalk_1.default.red
+                    : vuln.severity === "high"
+                        ? chalk_1.default.yellow
+                        : chalk_1.default.gray;
+                console.log(`  ${color(`[${vuln.severity.toUpperCase()}]`)} ${vuln.id}: ${vuln.description}`);
+            }
+        }
+        else {
+            console.log(chalk_1.default.green("\n✓ No vulnerabilities found"));
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`Error analyzing image: ${error}`));
+        console.log(chalk_1.default.gray("Make sure Docker is running and the image exists."));
+    }
+}
+exports.profileImage = profileImage;
+/**
+ * Generate and optionally apply optimizations
+ */
+async function optimizeContainer(options) {
+    console.log(chalk_1.default.cyan("\n⚡ ExpressoTS Container Optimizer\n"));
+    const cwd = process.cwd();
+    const dockerfilePath = path_1.default.join(cwd, options.dockerfile);
+    if (!fs_1.default.existsSync(dockerfilePath)) {
+        console.log(chalk_1.default.red(`Error: Dockerfile not found at ${dockerfilePath}`));
+        return;
+    }
+    const analysis = await (0, dockerfile_analyzer_1.analyzeDockerfile)(dockerfilePath);
+    const optimizations = (0, optimizers_1.generateOptimizations)(analysis);
+    if (optimizations.length === 0) {
+        console.log(chalk_1.default.green("✓ No optimizations needed. Your Dockerfile looks great!"));
+        return;
+    }
+    console.log(chalk_1.default.bold(`Found ${optimizations.length} optimization(s):\n`));
+    for (const opt of optimizations) {
+        const priorityColor = opt.priority === "high"
+            ? chalk_1.default.red
+            : opt.priority === "medium"
+                ? chalk_1.default.yellow
+                : chalk_1.default.gray;
+        console.log(`  ${priorityColor(`[${opt.priority.toUpperCase()}]`)} ${opt.title}`);
+        console.log(chalk_1.default.gray(`    ${opt.description}`));
+        console.log(chalk_1.default.green(`    Impact: ${opt.impact}`));
+        console.log();
+    }
+    if (options.autoFix) {
+        console.log(chalk_1.default.yellow("🔧 Applying safe optimizations..."));
+        const applied = await (0, optimizers_1.applyOptimizations)(dockerfilePath, optimizations);
+        console.log(chalk_1.default.green(`✓ Applied ${applied} optimization(s)`));
+    }
+    else {
+        console.log(chalk_1.default.gray("Tip: Use --auto-fix to automatically apply safe optimizations"));
+    }
+}
+exports.optimizeContainer = optimizeContainer;
+/**
+ * Show a comprehensive profile report
+ */
+async function showProfileReport(options) {
+    console.log(chalk_1.default.cyan("\n📊 ExpressoTS Container Profile Report\n"));
+    const cwd = process.cwd();
+    const dockerfilePath = path_1.default.join(cwd, options.dockerfile);
+    if (!fs_1.default.existsSync(dockerfilePath)) {
+        console.log(chalk_1.default.red(`Error: Dockerfile not found at ${dockerfilePath}`));
+        return;
+    }
+    const analysis = await (0, dockerfile_analyzer_1.analyzeDockerfile)(dockerfilePath);
+    const result = generateProfileResult(analysis, options);
+    // Generate report based on format
+    if (options.format === "json") {
+        const json = JSON.stringify(result, null, 2);
+        if (options.output) {
+            fs_1.default.writeFileSync(options.output, json, "utf-8");
+            console.log(chalk_1.default.green(`✓ Report saved to ${options.output}`));
+        }
+        else {
+            console.log(json);
+        }
+    }
+    else if (options.format === "html") {
+        const html = generateHtmlReport(result);
+        const outputPath = options.output || "container-report.html";
+        fs_1.default.writeFileSync(outputPath, html, "utf-8");
+        console.log(chalk_1.default.green(`✓ HTML report saved to ${outputPath}`));
+    }
+    else {
+        outputResult(result, options);
+    }
+}
+exports.showProfileReport = showProfileReport;
+/**
+ * Generate profile result from analysis
+ */
+function generateProfileResult(analysis, options) {
+    const issues = [];
+    const recommendations = [];
+    // Check for security issues
+    if (!analysis.hasNonRootUser) {
+        issues.push({
+            id: "SEC001",
+            severity: "high",
+            category: "security",
+            message: "Container runs as root user",
+            fix: "Add 'USER node' or create a non-root user",
+        });
+        recommendations.push({
+            priority: "high",
+            category: "Security",
+            title: "Add non-root user",
+            description: "Running containers as root is a security risk",
+            impact: "Reduces attack surface if container is compromised",
+        });
+    }
+    if (!analysis.hasHealthCheck) {
+        issues.push({
+            id: "PERF001",
+            severity: "medium",
+            category: "performance",
+            message: "No HEALTHCHECK instruction found",
+            fix: "Add HEALTHCHECK instruction for orchestration support",
+        });
+        recommendations.push({
+            priority: "medium",
+            category: "Performance",
+            title: "Add health check",
+            description: "Health checks enable better orchestration",
+            impact: "Faster failure detection and recovery",
+        });
+    }
+    if (!analysis.hasMultiStage) {
+        issues.push({
+            id: "SIZE001",
+            severity: "medium",
+            category: "size",
+            message: "Not using multi-stage build",
+            fix: "Use multi-stage build to reduce final image size",
+        });
+        recommendations.push({
+            priority: "medium",
+            category: "Size",
+            title: "Use multi-stage build",
+            description: "Multi-stage builds reduce image size significantly",
+            impact: "Can reduce image size by 50-80%",
+        });
+    }
+    // Check for best practices
+    if (analysis.hasNpmInstallWithoutCi) {
+        issues.push({
+            id: "BP001",
+            severity: "low",
+            category: "best-practice",
+            message: "Using 'npm install' instead of 'npm ci'",
+            fix: "Replace 'npm install' with 'npm ci' for reproducible builds",
+        });
+    }
+    if (!analysis.hasDockerignore) {
+        issues.push({
+            id: "SIZE002",
+            severity: "low",
+            category: "size",
+            message: "No .dockerignore file found",
+            fix: "Create .dockerignore to exclude unnecessary files",
+        });
+    }
+    if (analysis.hasCurlOrWgetWithoutCleanup) {
+        issues.push({
+            id: "SIZE003",
+            severity: "low",
+            category: "size",
+            message: "Downloaded files may not be cleaned up",
+            fix: "Clean up downloaded files in the same RUN layer",
+        });
+    }
+    // Calculate score
+    let score = 100;
+    for (const issue of issues) {
+        switch (issue.severity) {
+            case "critical":
+                score -= 25;
+                break;
+            case "high":
+                score -= 15;
+                break;
+            case "medium":
+                score -= 10;
+                break;
+            case "low":
+                score -= 5;
+                break;
+        }
+    }
+    score = Math.max(0, score);
+    return {
+        score,
+        issues: issues.filter((i) => {
+            const severityOrder = { low: 0, medium: 1, high: 2, critical: 3 };
+            return severityOrder[i.severity] >= severityOrder[options.severity];
+        }),
+        recommendations,
+        metrics: {
+            baseImage: analysis.baseImage,
+            layers: analysis.layers,
+            hasMultiStage: analysis.hasMultiStage,
+            hasHealthCheck: analysis.hasHealthCheck,
+            hasNonRootUser: analysis.hasNonRootUser,
+            nodeVersion: analysis.nodeVersion,
+        },
+    };
+}
+/**
+ * Output result to console
+ */
+function outputResult(result, options) {
+    // Score
+    const scoreColor = result.score >= 80
+        ? chalk_1.default.green
+        : result.score >= 60
+            ? chalk_1.default.yellow
+            : chalk_1.default.red;
+    console.log(chalk_1.default.bold(`Container Health Score: ${scoreColor(`${result.score}/100`)}\n`));
+    // Metrics
+    console.log(chalk_1.default.bold("Metrics:"));
+    console.log(`  Base Image: ${result.metrics.baseImage || "Unknown"}`);
+    console.log(`  Layers: ${result.metrics.layers || "Unknown"}`);
+    console.log(`  Multi-stage: ${result.metrics.hasMultiStage ? chalk_1.default.green("✓") : chalk_1.default.red("✗")}`);
+    console.log(`  Health Check: ${result.metrics.hasHealthCheck ? chalk_1.default.green("✓") : chalk_1.default.red("✗")}`);
+    console.log(`  Non-root User: ${result.metrics.hasNonRootUser ? chalk_1.default.green("✓") : chalk_1.default.red("✗")}`);
+    // Issues
+    if (result.issues.length > 0) {
+        console.log(chalk_1.default.bold(`\nIssues (${result.issues.length}):`));
+        for (const issue of result.issues) {
+            const color = issue.severity === "critical"
+                ? chalk_1.default.red
+                : issue.severity === "high"
+                    ? chalk_1.default.yellow
+                    : issue.severity === "medium"
+                        ? chalk_1.default.cyan
+                        : chalk_1.default.gray;
+            console.log(`  ${color(`[${issue.severity.toUpperCase()}]`)} ${issue.message}`);
+            if (issue.fix) {
+                console.log(chalk_1.default.gray(`    Fix: ${issue.fix}`));
+            }
+        }
+    }
+    else {
+        console.log(chalk_1.default.green("\n✓ No issues found!"));
+    }
+    // Recommendations
+    if (result.recommendations.length > 0) {
+        console.log(chalk_1.default.bold(`\nRecommendations:`));
+        for (const rec of result.recommendations) {
+            const color = rec.priority === "high" ? chalk_1.default.yellow : chalk_1.default.gray;
+            console.log(`  ${color(`[${rec.priority.toUpperCase()}]`)} ${rec.title}`);
+            console.log(chalk_1.default.gray(`    ${rec.description}`));
+        }
+    }
+    console.log();
+}
+/**
+ * Generate HTML report
+ */
+function generateHtmlReport(result) {
+    const scoreColor = result.score >= 80
+        ? "#22c55e"
+        : result.score >= 60
+            ? "#eab308"
+            : "#ef4444";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Container Profile Report - ExpressoTS</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #f3f4f6; padding: 2rem; }
+        .container { max-width: 800px; margin: 0 auto; }
+        .card { background: white; border-radius: 8px; padding: 1.5rem; margin-bottom: 1rem; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+        h1 { color: #111; margin-bottom: 0.5rem; }
+        h2 { color: #333; margin-bottom: 1rem; font-size: 1.25rem; }
+        .score { font-size: 3rem; font-weight: bold; color: ${scoreColor}; }
+        .metric { display: flex; justify-content: space-between; padding: 0.5rem 0; border-bottom: 1px solid #e5e7eb; }
+        .issue { padding: 0.75rem; margin: 0.5rem 0; border-radius: 4px; }
+        .issue.critical { background: #fef2f2; border-left: 4px solid #ef4444; }
+        .issue.high { background: #fffbeb; border-left: 4px solid #f59e0b; }
+        .issue.medium { background: #ecfeff; border-left: 4px solid #06b6d4; }
+        .issue.low { background: #f9fafb; border-left: 4px solid #9ca3af; }
+        .check { color: #22c55e; }
+        .cross { color: #ef4444; }
+        .footer { text-align: center; color: #6b7280; margin-top: 2rem; font-size: 0.875rem; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="card">
+            <h1>🐳 Container Profile Report</h1>
+            <p>Generated by ExpressoTS CLI</p>
+        </div>
+        
+        <div class="card">
+            <h2>Health Score</h2>
+            <div class="score">${result.score}/100</div>
+        </div>
+        
+        <div class="card">
+            <h2>Metrics</h2>
+            <div class="metric"><span>Base Image</span><span>${result.metrics.baseImage || "Unknown"}</span></div>
+            <div class="metric"><span>Layers</span><span>${result.metrics.layers || "Unknown"}</span></div>
+            <div class="metric"><span>Multi-stage Build</span><span class="${result.metrics.hasMultiStage ? "check" : "cross"}">${result.metrics.hasMultiStage ? "✓" : "✗"}</span></div>
+            <div class="metric"><span>Health Check</span><span class="${result.metrics.hasHealthCheck ? "check" : "cross"}">${result.metrics.hasHealthCheck ? "✓" : "✗"}</span></div>
+            <div class="metric"><span>Non-root User</span><span class="${result.metrics.hasNonRootUser ? "check" : "cross"}">${result.metrics.hasNonRootUser ? "✓" : "✗"}</span></div>
+        </div>
+        
+        <div class="card">
+            <h2>Issues (${result.issues.length})</h2>
+            ${result.issues.length === 0
+        ? '<p style="color: #22c55e;">✓ No issues found!</p>'
+        : result.issues
+            .map((i) => `
+                <div class="issue ${i.severity}">
+                    <strong>[${i.severity.toUpperCase()}]</strong> ${i.message}
+                    ${i.fix ? `<br><small style="color: #6b7280;">Fix: ${i.fix}</small>` : ""}
+                </div>
+            `)
+            .join("")}
+        </div>
+        
+        <div class="card">
+            <h2>Recommendations (${result.recommendations.length})</h2>
+            ${result.recommendations
+        .map((r) => `
+                <div class="issue low">
+                    <strong>${r.title}</strong><br>
+                    ${r.description}<br>
+                    <small style="color: #22c55e;">Impact: ${r.impact}</small>
+                </div>
+            `)
+        .join("")}
+        </div>
+        
+        <div class="footer">
+            Generated by ExpressoTS CLI • ${new Date().toISOString()}
+        </div>
+    </div>
+</body>
+</html>`;
+}

package/bin/profile/index.d.ts

@@ -0,0 +1 @@
+export { profileCommand } from "./cli";

package/bin/profile/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileCommand = void 0;
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "profileCommand", { enumerable: true, get: function () { return cli_1.profileCommand; } });

package/bin/profile/optimizers/index.d.ts

@@ -0,0 +1,19 @@
+import type { DockerfileAnalysis } from "../analyzers/dockerfile-analyzer";
+export interface Optimization {
+    id: string;
+    priority: "low" | "medium" | "high";
+    category: string;
+    title: string;
+    description: string;
+    impact: string;
+    autoFixable: boolean;
+    fix?: (content: string) => string;
+}
+/**
+ * Generate optimization recommendations based on Dockerfile analysis
+ */
+export declare function generateOptimizations(analysis: DockerfileAnalysis): Optimization[];
+/**
+ * Apply auto-fixable optimizations to Dockerfile
+ */
+export declare function applyOptimizations(dockerfilePath: string, optimizations: Optimization[]): Promise<number>;