bridgepreflight 1.0.0

package/README.md

@@ -0,0 +1,123 @@
+# BridgePreflight
+
+![BridgePreflight](https://github.com/GodsfavourJesse/bridgepreflight/actions/workflows/bridgepreflight.yml/badge.svg)
+
+
+<!------------------------------  ------------------------------------>
+BridgePreflight
+
+AI-native infrastructure readiness scanner for Node & TypeScript projects.
+
+BridgePreflight analyzes your repository before code merges and assigns a Preflight Readiness Score (0–100) — automatically blocking pull requests that introduce risk.
+<!------------------------------  ------------------------------------>
+
+
+<!------------------------------  ------------------------------------>
+The Problem
+Teams merge code that:
+    • Has no tests
+    • Breaks the build
+    • Lacks documentation
+    • Has weak repository hygiene
+Issues are discovered too late — during staging or production.
+
+BridgePreflight moves detection earlier — directly into CI.
+<!------------------------------  ------------------------------------>
+
+
+
+<!------------------------------  ------------------------------------>
+What BridgePreflight Does
+BridgePreflight scans your repository and:
+    • Generates an Infrastructure Readiness Score
+    • Classifies readiness (Ready / Caution / Critical)
+    • Identifies top risk factors
+    • Automatically fails PRs if score < 70
+    • Posts a structured risk summary comment on pull requests
+It integrates directly into GitHub Actions for seamless enforcement.
+<!------------------------------  ------------------------------------>
+
+
+
+<!------------------------------  ------------------------------------>
+How It Works
+BridgePreflight evaluates:
+    • Test presence and structure
+    • Build configuration
+    • CI workflow setup
+    • Documentation presence
+    • Repository hygiene
+Each category contributes weighted points to the final score.
+
+If the score falls below the threshold:
+    • The CI pipeline fails
+    • The merge button is blocked
+    • A risk summary is posted on the PR
+<!------------------------------  ------------------------------------>
+
+
+<!------------------------------  ------------------------------------>
+Installation (Local Usage)
+    npm install
+    npm run build
+    node dist/cli.js scan
+
+
+For machine-readable output:
+    node dist/cli.js scan --json
+<!------------------------------  ------------------------------------>
+
+
+<!------------------------------  ------------------------------------>
+GitHub Actions Integration
+Place this file in:
+    .github/workflows/bridgepreflight.yml
+
+
+BridgePreflight will:
+    • Run on every push to main
+    • Run on every pull request
+    • Automatically fail if readiness < 70
+    • Comment with risk breakdown
+<!------------------------------  ------------------------------------>
+
+
+<!------------------------------  ------------------------------------>
+Example Output
+    {
+        "totalScore": 82,
+        "readiness": "Ready",
+        "results": [
+            { "name": "Test Check", "severity": "healthy" },
+            { "name": "Build Check", "severity": "warning" }
+        ]
+    }
+<!------------------------------  ------------------------------------>
+
+
+<!------------------------------  ------------------------------------>
+Why BridgePreflight Matters
+BridgePreflight transforms infrastructure quality into a measurable metric.
+
+It acts as:
+    • A DevOps gatekeeper
+    • A pre-merge risk detection layer
+    • A credibility signal for repositories
+Instead of hoping code is safe — you measure it.
+<!------------------------------  ------------------------------------>
+
+
+<!------------------------------  ------------------------------------>
+Roadmap
+    • Configurable scoring weights
+    • Plugin-based analyzer system
+    • Historical score tracking
+    • SaaS dashboard
+    • AI-based remediation suggestions
+<!------------------------------  ------------------------------------>
+
+
+<!------------------------------  ------------------------------------>
+📄 License
+MIT
+<!------------------------------  ------------------------------------>

package/dist/analyzers/build.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildAnalyzer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const execa_1 = require("execa");
+const severity_1 = require("../utils/severity");
+class BuildAnalyzer {
+    constructor() {
+        this.name = "Build Check";
+        this.weight = 1.5;
+        this.supports = ["node"];
+        this.MAX_SCORE = 50;
+        this.BUILD_TIMEOUT_MS = 60000; // 60s safety timeout
+    }
+    async run() {
+        const projectRoot = process.cwd();
+        const packageJsonPath = path_1.default.join(projectRoot, "package.json");
+        const tsconfigPath = path_1.default.join(projectRoot, "tsconfig.json");
+        let score = this.MAX_SCORE;
+        const findings = [];
+        // 1. Ensure package.json exists
+        if (!fs_1.default.existsSync(packageJsonPath)) {
+            return {
+                name: this.name,
+                success: false,
+                findings: [
+                    {
+                        type: "error",
+                        message: "package.json file is missing.",
+                        suggestion: "Ensure this is a valid Node.js project with a package.json file.",
+                    },
+                ],
+                scoreImpact: 0,
+                maxScore: this.MAX_SCORE,
+                severity: "critical",
+            };
+        }
+        const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+        const hasBuildScript = Boolean(pkg.scripts?.build);
+        const usesTypeScript = fs_1.default.existsSync(tsconfigPath);
+        // 2. TypeScript but no build script
+        if (usesTypeScript && !hasBuildScript) {
+            score = 10;
+            findings.push({
+                type: "error",
+                message: "TypeScript project detected but no build script found in package.json.",
+                evidence: "tsconfig.json exists but scripts.build is undefined",
+                suggestion: 'Add a build script (e.g., `"build": "tsc"`) to compile TypeScript before deployment.',
+            });
+            return {
+                name: this.name,
+                success: false,
+                findings,
+                scoreImpact: score,
+                maxScore: this.MAX_SCORE,
+                severity: (0, severity_1.calculateSeverity)(score, this.MAX_SCORE),
+            };
+        }
+        // 3. No build script at all
+        if (!hasBuildScript) {
+            findings.push({
+                type: "warning",
+                message: "No build script found in package.json.",
+                suggestion: "Consider defining a build step to ensure consistent production builds.",
+            });
+            return {
+                name: this.name,
+                success: true,
+                findings,
+                scoreImpact: score,
+                maxScore: this.MAX_SCORE,
+                severity: (0, severity_1.calculateSeverity)(score, this.MAX_SCORE),
+            };
+        }
+        // Execute build safely
+        try {
+            const { stdout, stderr } = await (0, execa_1.execa)("npm", ["run", "build"], {
+                cwd: projectRoot,
+                timeout: this.BUILD_TIMEOUT_MS,
+            });
+            const combineOutput = `${stdout}\n${stderr}`;
+            const warningCount = (combineOutput.match(/warning/gi) || []).length;
+            if (warningCount > 0) {
+                const deduction = Math.min(warningCount * 2, 20);
+                score -= deduction;
+                findings.push({
+                    type: "warning",
+                    message: `${warningCount} build warning(s) detected.`,
+                    suggestion: "Resolve build warnings to improve production stability and reduce hidden runtime issues."
+                });
+            }
+            if (score < 0)
+                score = 0;
+            return {
+                name: this.name,
+                success: score === this.MAX_SCORE,
+                findings,
+                scoreImpact: score,
+                maxScore: this.MAX_SCORE,
+                severity: (0, severity_1.calculateSeverity)(score, this.MAX_SCORE),
+            };
+        }
+        catch (err) {
+            score = 0;
+            findings.push({
+                type: "error",
+                message: "Build execution failed.",
+                evidence: err?.stderr || err?.message,
+                suggestion: "Fix build errors before deployment. Ensure the project builds successfully in a clean environment."
+            });
+            return {
+                name: this.name,
+                success: false,
+                findings,
+                scoreImpact: score,
+                maxScore: this.MAX_SCORE,
+                severity: "critical"
+            };
+        }
+    }
+}
+exports.BuildAnalyzer = BuildAnalyzer;

package/dist/analyzers/env.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvAnalyzer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const severity_1 = require("../utils/severity");
+class EnvAnalyzer {
+    constructor() {
+        this.name = "Environment Variables Check";
+        this.weight = 1;
+        this.supports = ["all"];
+        this.MAX_SCORE = 30;
+    }
+    async run() {
+        const projectRoot = process.cwd();
+        const baseDir = fs_1.default.existsSync(path_1.default.join(projectRoot, "src"))
+            ? path_1.default.join(projectRoot, "src")
+            : projectRoot;
+        const files = (0, glob_1.globSync)("**/*.{ts,js,tsx,jsx,html,css}", {
+            cwd: baseDir,
+            ignore: ["node_modules/**", "dist/**"],
+            nodir: true
+        });
+        let score = this.MAX_SCORE;
+        const findings = [];
+        const envUsageFiles = [];
+        // Scan up to 300 files for performance safety
+        for (const file of files.slice(0, 300)) {
+            const content = fs_1.default.readFileSync(path_1.default.join(baseDir, file), "utf-8");
+            if (content.includes("process.env"))
+                envUsageFiles.push(file);
+        }
+        const usesEnv = envUsageFiles.length > 0;
+        // Check for any environment file variants
+        const envFiles = [
+            ".env",
+            ".env.local",
+            ".env.development",
+            ".env.production"
+        ];
+        const existingEnvFile = envFiles.find((f) => fs_1.default.existsSync(path_1.default.join(projectRoot, f)));
+        // Detect static HTML/CSS/JS projects
+        const isStaticProject = files.every((f) => /\.(html|css|js)$/.test(f));
+        // ----------- 1. Static projects with no env usage -----------
+        if (isStaticProject && !usesEnv) {
+            findings.push({
+                type: "info",
+                message: "No .env file and no process.env usage detected.",
+                suggestion: "If your project will need API calls or secrets in the future, consider adding a .env file."
+            });
+        }
+        else {
+            // ----------- 2. Process.env used but no env file -----------
+            if (usesEnv && !existingEnvFile) {
+                score -= 20;
+                findings.push({
+                    type: "error",
+                    message: ".env file is missing but process.env usage was detected.",
+                    evidence: `process.env found in ${envUsageFiles.length} file(s). Example: ${envUsageFiles.slice(0, 3).join(", ")}`,
+                    suggestion: "Create a .env file (or .env.local/.env.development) for local development or configure environment variables in your deployment platform."
+                });
+            }
+        }
+        // ----------- 3. Recommend .env.example even if env file exists -----------
+        if (!fs_1.default.existsSync(path_1.default.join(projectRoot, ".env.example"))) {
+            findings.push({
+                type: "info",
+                message: ".env.example file is missing.",
+                suggestion: "Add a .env.example file to document required environment variables for your team and CI/CD environments."
+            });
+        }
+        if (score < 0)
+            score = 0;
+        return {
+            name: this.name,
+            success: score === this.MAX_SCORE,
+            findings,
+            scoreImpact: score,
+            maxScore: this.MAX_SCORE,
+            severity: (0, severity_1.calculateSeverity)(score, this.MAX_SCORE)
+        };
+    }
+}
+exports.EnvAnalyzer = EnvAnalyzer;

package/dist/analyzers/network.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkAnalyzer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const severity_1 = require("../utils/severity");
+class NetworkAnalyzer {
+    constructor() {
+        this.name = "Localhost Leak Check";
+        this.weight = 1.2;
+        this.supports = ["all"];
+        this.MAX_SCORE = 20;
+        this.MAX_FILES_TO_SCAN = 500;
+    }
+    async run() {
+        const projectRoot = process.cwd();
+        const baseDir = fs_1.default.existsSync(path_1.default.join(projectRoot, "src"))
+            ? path_1.default.join(projectRoot, "src")
+            : projectRoot;
+        const files = (0, glob_1.globSync)("**/*.{ts,js,tsx,jsx}", {
+            cwd: baseDir,
+            ignore: ["node_modules/**", "dist/**"],
+            nodir: true
+        });
+        let score = this.MAX_SCORE;
+        const findings = [];
+        const leakFiles = [];
+        for (const file of files.slice(0, this.MAX_FILES_TO_SCAN)) {
+            const fullPath = path_1.default.join(baseDir, file);
+            const content = fs_1.default.readFileSync(fullPath, "utf-8");
+            // Basic but effective detection
+            if (content.includes("localhost") ||
+                content.includes("127.0.0.1")) {
+                leakFiles.push(file);
+            }
+        }
+        const leakCount = leakFiles.length;
+        if (leakCount > 0) {
+            // Deduct up to a max of 12 points (prevent total collapse)
+            const deduction = Math.min(leakCount * 2, 12);
+            score -= deduction;
+            findings.push({
+                type: leakCount > 5 ? "error" : "warning",
+                message: `${leakCount} hardcoded localhost reference(s) detected.`,
+                evidence: `Examples: ${leakFiles.slice(0, 5).join(", ")}`,
+                suggestion: "Replace hardcoded localhost or 127.0.0.1 URLs with environment-based configuration (e.g., process.env.API_BASE_URL).",
+            });
+        }
+        if (score < 0)
+            score = 0;
+        return {
+            name: this.name,
+            success: leakCount === 0,
+            findings,
+            scoreImpact: score,
+            maxScore: this.MAX_SCORE,
+            severity: (0, severity_1.calculateSeverity)(score, this.MAX_SCORE)
+        };
+    }
+}
+exports.NetworkAnalyzer = NetworkAnalyzer;

package/dist/analyzers/runtime.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeAnalyzer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const severity_1 = require("../utils/severity");
+class RuntimeAnalyzer {
+    constructor() {
+        this.name = "Runtime Compatibility Check";
+        this.weight = 2;
+        this.supports = ["node"];
+        this.MAX_SCORE = 20;
+    }
+    async run() {
+        const projectRoot = process.cwd();
+        const packageJsonPath = path_1.default.join(projectRoot, "package.json");
+        let score = 0;
+        const findings = [];
+        // Check Node engine declaration
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+            if (!pkg.engines?.node) {
+                score -= 8;
+                findings.push({
+                    type: "error",
+                    message: "Node.js version is not specified in package.json (engines.node missing).",
+                    evidence: "package.json does not define engines.node",
+                    suggestion: 'Add `"engines": { "node": ">=18.x" }` to package.json to enforce runtime consistency.',
+                });
+            }
+        }
+        else {
+            score = 0;
+            findings.push({
+                type: "error",
+                message: "package.json file is missing.",
+                suggestion: "Ensure this project is a valid Node.js project with a package.json file.",
+            });
+        }
+        // Check version manager config (.nvmrc / .node-version)
+        const hasNodeVersionFile = fs_1.default.existsSync(path_1.default.join(projectRoot, ".nvmrc")) ||
+            fs_1.default.existsSync(path_1.default.join(projectRoot, ".node-version"));
+        if (!hasNodeVersionFile) {
+            score -= 6;
+            findings.push({
+                type: "warning",
+                message: "No Node version manager file found (.nvmrc or .node-version).",
+                suggestion: "Add a .nvmrc or .node-version file to standardize Node.js versions across environments.",
+            });
+        }
+        // Check dependency lockfile
+        const lockfiles = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml"];
+        const detectedLockfile = lockfiles.find(file => fs_1.default.existsSync(path_1.default.join(projectRoot, file)));
+        if (!detectedLockfile) {
+            score -= 6;
+            findings.push({
+                type: "error",
+                message: "No dependency lockfile detected.",
+                evidence: "Missing package-lock.json, yarn.lock, or pnpm-lock.yaml",
+                suggestion: "Commit a lockfile to ensure deterministic dependency installation across environments.",
+            });
+        }
+        if (score < 0)
+            score = 0;
+        return {
+            name: this.name,
+            success: score === this.MAX_SCORE,
+            findings,
+            scoreImpact: score,
+            maxScore: this.MAX_SCORE,
+            severity: (0, severity_1.calculateSeverity)(score, this.MAX_SCORE),
+        };
+    }
+}
+exports.RuntimeAnalyzer = RuntimeAnalyzer;

package/dist/cli.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const scan_1 = require("./core/scan");
+const build_1 = require("./analyzers/build");
+const env_1 = require("./analyzers/env");
+const network_1 = require("./analyzers/network");
+const runtime_1 = require("./analyzers/runtime");
+const projectUtils_1 = require("./utils/projectUtils");
+const ci_1 = require("./utils/ci");
+const program = new commander_1.Command();
+function renderProgressBar(percentage, length = 20) {
+    const safe = Math.max(0, Math.min(percentage, 100));
+    const filled = Math.round((safe / 100) * length);
+    const bar = "█".repeat(filled) + "░".repeat(length - filled);
+    return `[${bar}] ${safe.toFixed(1)}%`;
+}
+program
+    .name("bridgepreflight")
+    .description("AI-native production safety scanner")
+    .version("0.0.1");
+program
+    .command("scan")
+    .option("--json", "Output results as JSON (for CI pipelines)")
+    .description("Run production safety checks")
+    .action(async (options) => {
+    console.log(chalk_1.default.blue("\nWelcome to BridgePreflight — AI-native infrastructure readiness scanner\n"));
+    const ciMode = (0, ci_1.isCI)();
+    if (!ciMode) {
+        const accessGranted = await (0, projectUtils_1.askProjectAccess)();
+        if (!accessGranted) {
+            console.log(chalk_1.default.blue("\nThank you for using BridgePreflight"));
+            process.exit(0);
+        }
+    }
+    else {
+        console.log(chalk_1.default.gray("CI environment detected — interactive prompts disabled."));
+    }
+    const projectType = (0, projectUtils_1.detectProjectType)();
+    if (projectType === "static") {
+        console.log(chalk_1.default.yellow("Detected static HTML/CSS/JS project. Node-specific checks will be skipped."));
+    }
+    let spinner;
+    try {
+        const ora = (await Promise.resolve().then(() => __importStar(require("ora")))).default;
+        spinner = ora("Running analyzers...").start();
+        const allAnalyzers = [
+            new build_1.BuildAnalyzer(),
+            new env_1.EnvAnalyzer(),
+            new network_1.NetworkAnalyzer(),
+            new runtime_1.RuntimeAnalyzer(),
+        ];
+        const analyzers = allAnalyzers.filter((a) => a.supports.includes(projectType) ||
+            a.supports.includes("all"));
+        const skippedAnalyzers = allAnalyzers.filter((a) => !analyzers.includes(a));
+        const engine = new scan_1.ScanEngine(analyzers);
+        const results = await engine.runAll();
+        spinner.stop();
+        // =============================
+        // 1. Scoring System
+        // =============================
+        let totalScore = 0;
+        let totalMaxScore = 0;
+        let weightedScore = 0;
+        let weightedMaxScore = 0;
+        results.forEach(({ analyzer, result }) => {
+            const weight = analyzer.weight ?? 1;
+            totalScore += result.scoreImpact;
+            totalMaxScore += result.maxScore;
+            weightedScore += result.scoreImpact * weight;
+            weightedMaxScore += result.maxScore * weight;
+        });
+        const percentage = weightedMaxScore === 0
+            ? 100
+            : (weightedScore / weightedMaxScore) * 100;
+        let readinessLabel;
+        let readinessColor;
+        if (percentage >= 90) {
+            readinessLabel = "Safe to Deploy";
+            readinessColor = chalk_1.default.green;
+        }
+        else if (percentage >= 70) {
+            readinessLabel = "Deploy with Caution";
+            readinessColor = chalk_1.default.yellow;
+        }
+        else {
+            readinessLabel = "High Risk";
+            readinessColor = chalk_1.default.red;
+        }
+        // =============================
+        // 2. Top Risk Detection
+        // =============================
+        let topRisk;
+        let lowestHealth = 101;
+        for (const { result } of results) {
+            if (result.maxScore === 0)
+                continue;
+            const health = (result.scoreImpact / result.maxScore) * 100;
+            if (health < lowestHealth) {
+                lowestHealth = health;
+                topRisk = {
+                    name: result.name,
+                    health,
+                };
+            }
+        }
+        // =============================
+        // JSON Output Mode
+        // =============================
+        if (options.json) {
+            console.log(JSON.stringify({
+                totalScore,
+                maxScore: totalMaxScore,
+                percentage,
+                readiness: readinessLabel,
+                results,
+            }, null, 2));
+            process.exit(percentage < 70 ? 1 : 0);
+        }
+        // =============================
+        // 3. Analyzer Overview
+        // =============================
+        console.log(chalk_1.default.blue("\n--- BridgePreflight Scan ---\n"));
+        results.forEach(({ result, duration }) => {
+            const health = result.maxScore === 0
+                ? 100
+                : (result.scoreImpact / result.maxScore) * 100;
+            const icon = health >= 90 ? "✅" :
+                health >= 70 ? "⚠" : "❌";
+            const color = health >= 90
+                ? chalk_1.default.green
+                : health >= 70
+                    ? chalk_1.default.yellow
+                    : chalk_1.default.red;
+            console.log(color(`${icon} ${result.name} (${result.scoreImpact}/${result.maxScore}) - ${duration}ms`));
+            console.log(color(`   ${renderProgressBar(health)}`));
+        });
+        // Show skipped analyzers clearly
+        skippedAnalyzers.forEach((a) => {
+            console.log(chalk_1.default.gray(`➖ ${a.name} skipped for ${projectType} project.`));
+        });
+        // =============================
+        // 4. Total Summary
+        // =============================
+        console.log(chalk_1.default.blue("\n-----------------------------"));
+        console.log(chalk_1.default.magenta.bold(`Total Score: ${totalScore}/${totalMaxScore} (${percentage.toFixed(1)}%)`));
+        console.log(chalk_1.default.gray("Weighted scoring applied based on risk category"));
+        console.log(readinessColor.bold(`Readiness: ${readinessLabel}`));
+        if (topRisk && topRisk.health < 100) {
+            const riskColor = topRisk.health >= 70
+                ? chalk_1.default.yellow
+                : chalk_1.default.red;
+            console.log(riskColor.bold(`Top Risk Area: ${topRisk.name} (${topRisk.health.toFixed(1)}% health)`));
+        }
+        else {
+            console.log(chalk_1.default.gray("Top Risk Area: None (all checks passed)"));
+        }
+        console.log(chalk_1.default.blue("-----------------------------\n"));
+        // =============================
+        // 5. Detailed Findings
+        // =============================
+        console.log(chalk_1.default.cyan.bold("--- Detailed Findings ---\n"));
+        results.forEach(({ analyzer, result }) => {
+            if (result.findings.length === 0)
+                return;
+            console.log(chalk_1.default.yellow.bold(`${analyzer.name} Findings:`));
+            result.findings.forEach((f) => {
+                const typeColor = f.type === "error"
+                    ? chalk_1.default.red.bold
+                    : f.type === "warning"
+                        ? chalk_1.default.yellow.bold
+                        : chalk_1.default.blue;
+                console.log(typeColor(`   • ${f.type.toUpperCase()}: ${f.message}`));
+                if (f.evidence) {
+                    console.log(chalk_1.default.gray(`     • Evidence: ${f.evidence}`));
+                }
+                if (f.suggestion) {
+                    console.log(chalk_1.default.cyan(`     → Suggested action: ${f.suggestion}`));
+                }
+            });
+            console.log("");
+        });
+        if (percentage < 70)
+            process.exit(1);
+    }
+    catch (error) {
+        if (spinner)
+            spinner.stop();
+        console.error(chalk_1.default.red("Error running scan:"), error);
+        process.exit(1);
+    }
+});
+program.parse(process.argv);

package/dist/core/scan.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanEngine = void 0;
+class ScanEngine {
+    constructor(analyzers) {
+        this.analyzers = analyzers;
+    }
+    async runAll() {
+        const results = [];
+        for (const analyzer of this.analyzers) {
+            const start = Date.now();
+            const result = await analyzer.run();
+            const duration = Date.now() - start;
+            results.push({
+                analyzer,
+                result,
+                duration,
+            });
+        }
+        return results;
+    }
+}
+exports.ScanEngine = ScanEngine;

package/dist/output/console.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJECT_TYPES = void 0;
+exports.PROJECT_TYPES = {
+    NODE: "node",
+    STATIC: "static",
+    FRONTEND: "frontend",
+};

package/dist/utils/ci.js

@@ -0,0 +1,18 @@
+"use strict";
+// Detects whether BridgePreflight is running in a CI environment.
+// Supports major CI providers and generic CI flag.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCI = isCI;
+function isCI() {
+    const env = process.env;
+    return Boolean(env.CI ||
+        env.GITHUB_ACTIONS ||
+        env.GITLAB_CI ||
+        env.BITBUCKET_BUILD_NUMBER ||
+        env.CIRCLECI ||
+        env.BUILDKITE ||
+        env.TRAVIS ||
+        env.TEAMCITY_VERSION ||
+        env.AZURE_HTTP_USER_AGENT ||
+        env.JENKINS_URL);
+}

package/dist/utils/projectUtils.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = prompt;
+exports.askProjectAccess = askProjectAccess;
+exports.detectProjectType = detectProjectType;
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const readline_1 = __importDefault(require("readline"));
+const ci_1 = require("./ci");
+// Prompt user with a question in CLI
+async function prompt(question) {
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+}
+// Ask the developer for permission to scan the project
+async function askProjectAccess() {
+    if ((0, ci_1.isCI)())
+        return true;
+    const answer = await prompt(chalk_1.default.blackBright("BridgePreflight needs access to scan your entire project. Allow? (y/n): "));
+    return answer === "y";
+}
+// Detect project type: Node, Frontend, or Static HTML/CSS/JS
+function detectProjectType() {
+    const files = fs_1.default.readdirSync(process.cwd());
+    if (files.includes("package.json"))
+        return "node";
+    if (files.some(f => f.endsWith(".html")))
+        return "static";
+    return "frontend";
+}

package/dist/utils/severity.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSeverity = calculateSeverity;
+function calculateSeverity(score, max) {
+    const percent = max === 0 ? 100 : (score / max) * 100;
+    if (percent === 100)
+        return "healthy";
+    if (percent >= 75)
+        return "low";
+    if (percent >= 50)
+        return "medium";
+    if (percent >= 25)
+        return "high";
+    return "critical";
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "bridgepreflight",
+    "version": "1.0.0",
+    "description": "AI-native production readiness scanner for developers",
+    "bin": {
+        "bridgepreflight": "./dist/cli.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "dev": "ts-node src/cli.ts",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "devtools",
+        "ci",
+        "production",
+        "deployment",
+        "node",
+        "scanner"
+    ],
+    "author": "Godsfavour Jesse",
+    "license": "MIT",
+    "type": "commonjs",
+    "dependencies": {
+        "chalk": "^5.6.2",
+        "commander": "^14.0.3",
+        "execa": "^9.6.1",
+        "glob": "^13.0.2",
+        "ora": "^9.3.0"
+    },
+    "devDependencies": {
+        "@types/glob": "^8.1.0",
+        "@types/node": "^25.2.3",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.9.3"
+    },
+    "engines": {
+        "node": ">=18"
+    }
+}