bandit-cli 1.0.3 → 1.0.6

package/dist/cli/output.js

@@ -6,71 +6,54 @@ function icon(status) {
         return chalk.red("✖");
     return chalk.gray("-");
 }
-function sevColor(sev, text) {
-    if (sev === "error")
-        return chalk.red(text);
-    if (sev === "warn")
-        return chalk.yellow(text);
-    return chalk.blue(text);
-}
-function sevLabel(sev) {
-    if (sev === "error")
-        return "ERROR";
-    if (sev === "warn")
-        return "WARN";
-    return "INFO";
-}
 function printSeparator() {
-    console.log(chalk.gray("─".repeat(80)));
+    console.log(chalk.gray("  " + "─".repeat(70)));
 }
 function printItem(item) {
     const statusIcon = icon(item.status);
-    const line = `${statusIcon} ${chalk.bold(item.title)}`;
-    console.log(line);
-    // Show details for pass/fail/skip
+    let titleText = chalk.bold(item.title);
+    if (item.status === "fail") {
+        if (item.severity === "error")
+            titleText += chalk.red.bold(" (ERROR)");
+        else if (item.severity === "warn")
+            titleText += chalk.yellow.bold(" (WARN)");
+        else
+            titleText += chalk.blue.bold(" (INFO)");
+    }
+    console.log(`  ${statusIcon}  ${titleText}`);
+    // Show details
     if (item.details) {
-        console.log(chalk.gray(`  ↳ ${item.details}`));
+        console.log(chalk.gray(`     ↳ ${item.details}`));
     }
     // Show suggestion only for failures
     if (item.status === "fail" && item.suggestion) {
-        console.log(chalk.gray(`  ↳ Suggestion: ${item.suggestion}`));
-    }
-}
-function printSection(title, items, color) {
-    if (items.length === 0)
-        return;
-    console.log("");
-    console.log(color(chalk.bold(`● ${title}`)));
-    printSeparator();
-    for (const item of items) {
-        printItem(item);
+        console.log(chalk.cyan(`     ↳ Suggestion: ${item.suggestion}`));
     }
 }
 export function printHuman(report) {
-    // Header
+    // Header Box
     console.log("");
-    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
-    console.log(chalk.bold.white(`                           Backend Audit Report`));
-    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
-    console.log(chalk.gray(`Project: ${report.projectPath}`));
-    console.log(chalk.gray(`Summary: ${chalk.green(`pass=${report.summary.pass}`)} ${chalk.red(`fail=${report.summary.fail}`)} ${chalk.gray(`skip=${report.summary.skip}`)}`));
+    console.log(chalk.cyan(`  ┌${"─".repeat(70)}┐`));
+    console.log(chalk.cyan(`  │`) + chalk.bold.white("                    BACKEND PROJECT AUDIT SUMMARY                     ") + chalk.cyan(`│`));
+    console.log(chalk.cyan(`  └${"─".repeat(70)}┘`));
+    console.log(`    ${chalk.gray("Project:")} ${chalk.bold(report.projectPath)}`);
+    console.log(`    ${chalk.gray("Results:")} ${chalk.green(`${report.summary.pass} Passed`)}, ` +
+        `${chalk.red(`${report.summary.fail} Failed`)}, ` +
+        `${chalk.gray(`${report.summary.skip} Skipped`)}`);
     // Severity Legend
     console.log("");
-    console.log(chalk.bold("Severity Legend:"));
-    console.log(chalk.red("  ● ERROR  ") +
-        chalk.gray("- Critical issues that must be fixed"));
-    console.log(chalk.yellow("  ● WARN   ") +
-        chalk.gray("- Important issues that should be addressed"));
-    console.log(chalk.blue("  ● INFO   ") +
-        chalk.gray("- Informational items or best practices"));
-    // Group items by status first
+    console.log(`    ${chalk.bold.gray("Severity Legend:")}  ` +
+        `${chalk.red("● ERROR")} (Critical)   ` +
+        `${chalk.yellow("● WARN")} (Important)   ` +
+        `${chalk.blue("● INFO")} (Best Practice)`);
+    // Group items
     const passedItems = report.items.filter((item) => item.status === "pass");
     const failedItems = report.items.filter((item) => item.status === "fail");
     const skippedItems = report.items.filter((item) => item.status === "skip");
     // Print PASSED section
     if (passedItems.length > 0) {
         console.log("");
-        console.log(chalk.bold.green(`✓ PASSED CHECKS (${passedItems.length})`));
+        console.log(chalk.bold.green(`  ✔ PASSED CHECKS (${passedItems.length})`));
         printSeparator();
         for (const item of passedItems) {
             printItem(item);
@@ -79,16 +62,15 @@ export function printHuman(report) {
     // Print FAILED sections grouped by severity
     if (failedItems.length > 0) {
         console.log("");
-        console.log(chalk.bold.red(`✖ FAILED CHECKS (${failedItems.length})`));
+        console.log(chalk.bold.red(`  ✖ FAILED CHECKS (${failedItems.length})`));
         printSeparator();
-        // Group failed items by severity
         const failedErrors = failedItems.filter((item) => item.severity === "error");
         const failedWarns = failedItems.filter((item) => item.severity === "warn");
         const failedInfos = failedItems.filter((item) => item.severity === "info");
         // Print failed ERRORS
         if (failedErrors.length > 0) {
             console.log("");
-            console.log(chalk.red(chalk.bold(`  ● ERRORS (${failedErrors.length})`)));
+            console.log(chalk.red(chalk.bold(`    ● ERRORS (${failedErrors.length})`)));
             for (const item of failedErrors) {
                 console.log("");
                 printItem(item);
@@ -97,7 +79,7 @@ export function printHuman(report) {
         // Print failed WARNINGS
         if (failedWarns.length > 0) {
             console.log("");
-            console.log(chalk.yellow(chalk.bold(`  ● WARNINGS (${failedWarns.length})`)));
+            console.log(chalk.yellow(chalk.bold(`    ● WARNINGS (${failedWarns.length})`)));
             for (const item of failedWarns) {
                 console.log("");
                 printItem(item);
@@ -106,7 +88,7 @@ export function printHuman(report) {
         // Print failed INFO
         if (failedInfos.length > 0) {
             console.log("");
-            console.log(chalk.blue(chalk.bold(`  ● INFO (${failedInfos.length})`)));
+            console.log(chalk.blue(chalk.bold(`    ● INFO (${failedInfos.length})`)));
             for (const item of failedInfos) {
                 console.log("");
                 printItem(item);
@@ -116,23 +98,24 @@ export function printHuman(report) {
     // Print SKIPPED section (if any)
     if (skippedItems.length > 0) {
         console.log("");
-        console.log(chalk.bold.gray(`- SKIPPED CHECKS (${skippedItems.length})`));
+        console.log(chalk.bold.gray(`  - SKIPPED CHECKS (${skippedItems.length})`));
         printSeparator();
         for (const item of skippedItems) {
             printItem(item);
         }
     }
-    // Footer
-    console.log("");
-    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
-    // Summary message
+    // Footer Box
     const failCount = report.summary.fail;
+    console.log("");
     if (failCount === 0) {
-        console.log(chalk.green.bold(`✓ All checks passed!`));
+        console.log(chalk.green(`  ┌${"─".repeat(70)}┐`));
+        console.log(chalk.green(`  │`) + chalk.bold.green("  ✔ All audits passed successfully!                                   ") + chalk.green(`│`));
+        console.log(chalk.green(`  └${"─".repeat(70)}┘`));
     }
     else {
-        console.log(chalk.yellow(`                         ⚠ ${failCount} check${failCount > 1 ? "s" : ""} need${failCount === 1 ? "s" : ""} attention.`));
+        console.log(chalk.yellow(`  ┌${"─".repeat(70)}┐`));
+        console.log(chalk.yellow(`  │`) + chalk.bold.yellow("  ⚠ Audit completed with warnings/errors. Check issues above.         ") + chalk.yellow(`│`));
+        console.log(chalk.yellow(`  └${"─".repeat(70)}┘`));
     }
-    console.log(chalk.bold.blue(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
     console.log("");
 }

package/dist/cli/studio.js

@@ -0,0 +1,54 @@
+import * as clack from "@clack/prompts";
+import chalk from "chalk";
+import { exec } from "node:child_process";
+import { startStudioServer } from "../studio/server.js";
+export async function runStudioCommand(projectPath = ".") {
+    clack.intro(chalk.bold.bgBlue.white(" Bandit Studio "));
+    const s = clack.spinner();
+    s.start("Starting Bandit Studio local server...");
+    try {
+        const { server, port } = await startStudioServer(projectPath, 4000);
+        const url = `http://localhost:${port}`;
+        s.stop(`Bandit Studio server running at ${chalk.bold.cyan(url)}`);
+        clack.log.info("Press Ctrl+C to stop the studio server.");
+        let isShuttingDown = false;
+        const shutdown = () => {
+            if (isShuttingDown)
+                return;
+            isShuttingDown = true;
+            console.log(chalk.bold.yellow("\nStopping Bandit Studio server... Goodbye!"));
+            try {
+                server.close();
+            }
+            catch { }
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        // Windows PowerShell / Terminal raw input listener for Ctrl+C (\u0003)
+        if (process.stdin.isTTY) {
+            try {
+                process.stdin.setRawMode(true);
+                process.stdin.resume();
+                process.stdin.on("data", (chunk) => {
+                    const str = chunk.toString();
+                    if (str === "\u0003" || str === "\u001b" || str.includes("\u0003")) {
+                        shutdown();
+                    }
+                });
+            }
+            catch { }
+        }
+        // Attempt auto-opening browser
+        const startCmd = process.platform === "win32" ? `start ${url}` : process.platform === "darwin" ? `open ${url}` : `xdg-open ${url}`;
+        exec(startCmd, (err) => {
+            if (err) {
+                clack.log.warn(`Could not open browser automatically. Please open ${url} in your browser.`);
+            }
+        });
+    }
+    catch (err) {
+        s.stop("Failed to start Bandit Studio server.");
+        clack.log.error(`Server startup error: ${err.message}`);
+    }
+}

package/dist/index.js

@@ -14,7 +14,9 @@ program
     .option("--json", "Print results as JSON")
     .option("--fail-on-warn", "Exit with code 1 if warnings exist")
     .action(async (projectPath, opts) => {
-    const results = await runAudit(projectPath);
+    const { resolveProjectPath } = await import("./utils/monorepo.js");
+    const resolvedPath = await resolveProjectPath(projectPath || ".");
+    const results = await runAudit(resolvedPath);
     if (opts.json) {
         process.stdout.write(JSON.stringify(results, null, 2) + "\n");
     }
@@ -42,8 +44,10 @@ program
     .description("Audit local .env configurations against .env.example")
     .argument("[path]", "Path to the project", ".")
     .action(async (projectPath) => {
+    const { resolveProjectPath } = await import("./utils/monorepo.js");
+    const resolvedPath = await resolveProjectPath(projectPath || ".");
     const { runEnvCommand } = await import("./cli/env.js");
-    await runEnvCommand(projectPath);
+    await runEnvCommand(resolvedPath);
 });
 // Subcommand: doctor
 program
@@ -65,8 +69,15 @@ program
     .option("-t, --token <token>", "Bearer Auth token")
     .option("-H, --header <headers...>", "Custom headers in Key:Value format")
     .action(async (methodOrPath, routePath, opts) => {
+    const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+    const isDirectMode = routePath !== undefined && httpMethods.includes(methodOrPath.toUpperCase());
+    let targetPath = methodOrPath;
+    if (!isDirectMode) {
+        const { resolveProjectPath } = await import("./utils/monorepo.js");
+        targetPath = await resolveProjectPath(methodOrPath || ".");
+    }
     const { runApiCommand } = await import("./cli/api.js");
-    await runApiCommand(methodOrPath, routePath, opts);
+    await runApiCommand(targetPath, routePath, opts);
 });
 // Subcommand: bench
 program
@@ -89,6 +100,17 @@ program
     const { runBenchCommand } = await import("./cli/bench.js");
     await runBenchCommand(url, { connections, requests });
 });
+// Subcommand: studio
+program
+    .command("studio")
+    .description("Launch Bandit Studio local web dashboard")
+    .argument("[path]", "Path to the project", ".")
+    .action(async (projectPath) => {
+    const { resolveProjectPath } = await import("./utils/monorepo.js");
+    const resolvedPath = await resolveProjectPath(projectPath || ".");
+    const { runStudioCommand } = await import("./cli/studio.js");
+    await runStudioCommand(resolvedPath);
+});
 // Default to help if no command specified
 if (!process.argv.slice(2).length) {
     program.outputHelp();

package/dist/studio/db.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+export class StudioDB {
+    baseDir;
+    constructor(projectPath = ".") {
+        this.baseDir = path.join(path.resolve(projectPath), ".bandit");
+        this.ensureDir();
+    }
+    ensureDir() {
+        if (!fs.existsSync(this.baseDir)) {
+            fs.mkdirSync(this.baseDir, { recursive: true });
+        }
+    }
+    getFilePath(filename) {
+        return path.join(this.baseDir, filename);
+    }
+    readJson(filename, defaultValue) {
+        const file = this.getFilePath(filename);
+        if (!fs.existsSync(file))
+            return defaultValue;
+        try {
+            const content = fs.readFileSync(file, "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            return defaultValue;
+        }
+    }
+    writeJson(filename, data) {
+        const file = this.getFilePath(filename);
+        fs.writeFileSync(file, JSON.stringify(data, null, 2), "utf-8");
+    }
+    getGitMetadata() {
+        try {
+            const commit = execSync("git rev-parse --short HEAD", { stdio: ["ignore", "pipe", "ignore"] })
+                .toString()
+                .trim();
+            const branch = execSync("git branch --show-current", { stdio: ["ignore", "pipe", "ignore"] })
+                .toString()
+                .trim();
+            const author = execSync('git log -1 --pretty=format:"%an"', { stdio: ["ignore", "pipe", "ignore"] })
+                .toString()
+                .trim();
+            return { commit, branch, author };
+        }
+        catch {
+            return {};
+        }
+    }
+    saveBenchmark(data) {
+        const records = this.readJson("benchmarks.json", []);
+        const git = this.getGitMetadata();
+        const newRecord = {
+            id: Math.random().toString(36).substring(2, 10),
+            timestamp: new Date().toISOString(),
+            gitCommit: git.commit,
+            gitBranch: git.branch,
+            gitAuthor: git.author,
+            ...data,
+        };
+        records.unshift(newRecord);
+        this.writeJson("benchmarks.json", records.slice(0, 200));
+        return newRecord;
+    }
+    getBenchmarks() {
+        return this.readJson("benchmarks.json", []);
+    }
+    saveAudit(items) {
+        const records = this.readJson("audits.json", []);
+        const git = this.getGitMetadata();
+        const newRecord = {
+            id: Math.random().toString(36).substring(2, 10),
+            timestamp: new Date().toISOString(),
+            gitCommit: git.commit,
+            items,
+        };
+        records.unshift(newRecord);
+        this.writeJson("audits.json", records.slice(0, 50));
+        return newRecord;
+    }
+    getAudits() {
+        return this.readJson("audits.json", []);
+    }
+    getConfig() {
+        return this.readJson("config.json", { dismissedRules: [] });
+    }
+    dismissRule(ruleTitle) {
+        const config = this.getConfig();
+        if (!config.dismissedRules.includes(ruleTitle)) {
+            config.dismissedRules.push(ruleTitle);
+            this.writeJson("config.json", config);
+        }
+        return config;
+    }
+}

package/dist/studio/scanner.js

@@ -0,0 +1,66 @@
+import { scanForRoutes } from "../cli/api.js";
+import { StudioDB } from "./db.js";
+export async function generateApiBlueprint(projectPath) {
+    const rawRoutes = await scanForRoutes(projectPath);
+    const db = new StudioDB(projectPath);
+    const benchmarks = db.getBenchmarks();
+    // Filter out non-route scans (like test files or CLI internal strings)
+    const routes = rawRoutes.filter(r => !r.sourceFile.includes("cli/") &&
+        !r.sourceFile.includes("doctor.") &&
+        !r.sourceFile.includes("api.") &&
+        r.routePath.startsWith("/") &&
+        !r.routePath.includes("-") // exclude header test strings like /access-control-allow-origin
+    );
+    const nodes = [];
+    const edges = [];
+    // Infrastructure Nodes
+    nodes.push({ id: "db:pg", label: "PostgreSQL Database", type: "database", details: "Primary Data Store & Connection Pool" });
+    nodes.push({ id: "cache:redis", label: "Redis Cache Layer", type: "cache", details: "In-Memory Response & Session Cache" });
+    const addedControllers = new Set();
+    const addedServices = new Set();
+    routes.forEach((r, idx) => {
+        const routeId = `route:${idx}`;
+        const routeLabel = `[${r.method}] ${r.routePath}`;
+        // Find matching telemetry if benchmarked
+        const matchBench = benchmarks.find(b => b.targetUrl.endsWith(r.routePath));
+        const metrics = matchBench ? { rps: matchBench.rps, p99: matchBench.latency.p99, avg: matchBench.latency.avg } : undefined;
+        nodes.push({
+            id: routeId,
+            label: routeLabel,
+            type: "route",
+            details: r.sourceFile,
+            metrics,
+        });
+        const controllerName = r.sourceFile.split(/[/\\]/).pop() || "Controller";
+        const controllerId = `controller:${controllerName}`;
+        if (!addedControllers.has(controllerId)) {
+            addedControllers.add(controllerId);
+            nodes.push({
+                id: controllerId,
+                label: controllerName,
+                type: "controller",
+                details: r.sourceFile,
+            });
+            // Map controller to corresponding service layer
+            const serviceName = controllerName.replace(".controller.", ".service.").replace("controller", "service");
+            const serviceId = `service:${serviceName}`;
+            if (!addedServices.has(serviceId)) {
+                addedServices.add(serviceId);
+                nodes.push({
+                    id: serviceId,
+                    label: serviceName,
+                    type: "service",
+                    details: `Business logic & DB ORM mapping`,
+                });
+                // Link Service to Infrastructure
+                edges.push({ from: serviceId, to: "db:pg", label: "queries" });
+                if (serviceName.toLowerCase().includes("product") || serviceName.toLowerCase().includes("catalog") || serviceName.toLowerCase().includes("cache")) {
+                    edges.push({ from: serviceId, to: "cache:redis", label: "hits cache" });
+                }
+            }
+            edges.push({ from: controllerId, to: serviceId, label: "delegates" });
+        }
+        edges.push({ from: routeId, to: controllerId, label: "handles" });
+    });
+    return { nodes, edges };
+}