prompt-injection-bench 1.0.1

package/dist/cli.js

@@ -0,0 +1,779 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command as Command7 } from "commander";
+
+// src/cli/commands/attack.command.ts
+import { MockAdapter } from "@reaatech/pi-bench-adapters";
+import { getCategoryIds } from "@reaatech/pi-bench-core";
+import { generateDefaultCorpus } from "@reaatech/pi-bench-corpus";
+import { createLogger } from "@reaatech/pi-bench-observability";
+import { createAttackExecutor } from "@reaatech/pi-bench-runner";
+import { createSafeExecution } from "@reaatech/pi-bench-runner";
+import { Command } from "commander";
+var logger = createLogger();
+function createAttackCommand() {
+  const command = new Command("attack");
+  command.description("Run single attack category against a defense").requiredOption("--category <category>", "Attack category to run").requiredOption("-d, --defense <name>", "Defense adapter name").option("-n, --count <number>", "Number of attacks to run", "50").option("-o, --output <file>", "Output file for results").option("-t, --timeout <ms>", "Timeout per attack in ms", "30000").action(async (options) => {
+    const category = options.category;
+    const defenseName = options.defense;
+    const count = Number.parseInt(options.count, 10);
+    const timeoutMs = Number.parseInt(options.timeout, 10);
+    logger.info("Running attack", { category, defense: defenseName, count });
+    const validCategories = getCategoryIds();
+    if (!validCategories.includes(category)) {
+      console.error(`Invalid category: ${category}`);
+      console.error(`Valid categories: ${validCategories.join(", ")}`);
+      process.exit(1);
+    }
+    try {
+      let adapter;
+      if (defenseName.toLowerCase() === "mock") {
+        adapter = new MockAdapter(0.85, 0.05);
+      } else {
+        adapter = await loadAdapter(defenseName);
+      }
+      await adapter.initialize?.();
+      const executor = createAttackExecutor({ timeoutMs });
+      const sandbox = createSafeExecution({ maxExecutionMs: timeoutMs });
+      const corpus = generateDefaultCorpus();
+      const categorySamples = corpus.filter((s) => s.category === category).slice(0, count);
+      if (categorySamples.length === 0) {
+        console.error(`No samples found for category: ${category}`);
+        process.exit(1);
+      }
+      console.log(`
+=== Attack Results: ${category} ===`);
+      console.log(`Defense: ${defenseName}`);
+      console.log(`Samples: ${categorySamples.length}`);
+      console.log("");
+      let detected = 0;
+      let bypassed = 0;
+      let errors = 0;
+      const results = [];
+      for (const sample of categorySamples) {
+        const context = sandbox.createContext(`run-${Date.now().toString(36)}`, sample.id);
+        const result = await sandbox.wrapAsync(async () => {
+          return executor.executeAttack(sample, adapter, defenseName);
+        }, context);
+        if (result.error) {
+          errors++;
+          console.log(`[ERROR] ${sample.id}: ${result.error}`);
+        } else if (result.success && result.data) {
+          const r = result.data;
+          results.push(r);
+          if (r.detected) {
+            detected++;
+            console.log(
+              `[DETECTED] ${sample.id} (confidence: ${(r.confidence * 100).toFixed(0)}%)`
+            );
+          } else {
+            bypassed++;
+            console.log(`[BYPASSED] ${sample.id}`);
+          }
+        }
+      }
+      console.log("\n=== Summary ===");
+      console.log(
+        `Detected: ${detected} (${(detected / categorySamples.length * 100).toFixed(1)}%)`
+      );
+      console.log(
+        `Bypassed: ${bypassed} (${(bypassed / categorySamples.length * 100).toFixed(1)}%)`
+      );
+      console.log(`Errors: ${errors}`);
+      if (options.output) {
+        const fs = await import("fs");
+        fs.writeFileSync(
+          options.output,
+          JSON.stringify(
+            {
+              category,
+              defense: defenseName,
+              totalSamples: categorySamples.length,
+              detected,
+              bypassed,
+              errors,
+              results,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            null,
+            2
+          )
+        );
+        logger.info(`Results written to ${options.output}`);
+      }
+      await adapter.cleanup?.();
+    } catch (error) {
+      logger.error("Attack failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+async function loadAdapter(name) {
+  switch (name.toLowerCase()) {
+    case "rebuff":
+      return (await import("@reaatech/pi-bench-adapters")).createRebuffAdapter();
+    case "lakera":
+      return (await import("@reaatech/pi-bench-adapters")).createLakeraAdapter();
+    case "llm-guard":
+      return (await import("@reaatech/pi-bench-adapters")).createLLMGuardAdapter();
+    case "garak":
+      return (await import("@reaatech/pi-bench-adapters")).createGarakAdapter();
+    default:
+      throw new Error(`Unknown defense adapter: ${name}`);
+  }
+}
+
+// src/cli/commands/benchmark.command.ts
+import { createMockAdapter } from "@reaatech/pi-bench-adapters";
+import { validateEnvironment } from "@reaatech/pi-bench-adapters";
+import { getCategoryIds as getCategoryIds2 } from "@reaatech/pi-bench-core";
+import { generateDefaultCorpus as generateDefaultCorpus2 } from "@reaatech/pi-bench-corpus";
+import { createLogger as createLogger2 } from "@reaatech/pi-bench-observability";
+import { createBenchmarkEngine } from "@reaatech/pi-bench-runner";
+import { createDefenseEvaluator } from "@reaatech/pi-bench-runner";
+import { generateBenignSamples } from "@reaatech/pi-bench-runner";
+import { Command as Command2 } from "commander";
+var logger2 = createLogger2();
+function loadAdapter2(name) {
+  switch (name.toLowerCase()) {
+    case "mock":
+      return createMockAdapter(0.85, 0.05);
+    case "rebuff":
+      return import("@reaatech/pi-bench-adapters").then((m) => m.createRebuffAdapter());
+    case "lakera":
+      return import("@reaatech/pi-bench-adapters").then((m) => m.createLakeraAdapter());
+    case "llm-guard":
+      return import("@reaatech/pi-bench-adapters").then((m) => m.createLLMGuardAdapter());
+    case "garak":
+      return import("@reaatech/pi-bench-adapters").then((m) => m.createGarakAdapter());
+    case "moderation-openai":
+    case "moderation-azure":
+    case "moderation-anthropic":
+    case "moderation-cohere": {
+      const provider = name.toLowerCase().replace("moderation-", "");
+      return import("@reaatech/pi-bench-adapters").then(
+        (m) => m.createModerationAdapter({ provider })
+      );
+    }
+    default:
+      throw new Error(
+        `Unknown defense adapter: ${name}. Available: mock, rebuff, lakera, llm-guard, garak, moderation-{provider}`
+      );
+  }
+}
+function createBenchmarkCommand() {
+  const command = new Command2("benchmark");
+  command.description("Run full benchmark against defenses").requiredOption("-d, --defense <name>", "Defense adapter name").option("-c, --corpus <version>", "Corpus version to use", "2026.04").option("--categories <categories>", "Comma-separated categories to include").option("-p, --parallel <count>", "Number of parallel executions", "10").option("-t, --timeout <ms>", "Timeout per attack in ms", "30000").option("-o, --output <file>", "Output file for results").option("--benign-count <number>", "Number of benign samples", "100").action(async (options) => {
+    validateEnvironment();
+    const defenseName = options.defense;
+    const corpusVersion = options.corpus;
+    const parallel = Number.parseInt(options.parallel, 10);
+    const timeoutMs = Number.parseInt(options.timeout, 10);
+    const benignCount = Number.parseInt(options.benignCount, 10);
+    let categories;
+    if (options.categories) {
+      categories = options.categories.split(",").map((c) => c.trim());
+    }
+    logger2.info("Starting benchmark", {
+      defense: defenseName,
+      corpus: corpusVersion,
+      parallel,
+      timeoutMs
+    });
+    try {
+      const adapter = await loadAdapter2(defenseName);
+      await adapter.initialize?.();
+      const engine = createBenchmarkEngine({
+        maxParallel: parallel,
+        defaultTimeoutMs: timeoutMs
+      });
+      engine.setAdapter(adapter);
+      const corpus = generateDefaultCorpus2();
+      const attackSamples = categories ? corpus.filter((s) => categories.includes(s.category)) : corpus;
+      const benignSamples = generateBenignSamples(benignCount);
+      const progressCallback = (progress) => {
+        logger2.info("Progress", {
+          completed: progress.completed,
+          total: progress.total,
+          detected: progress.detected,
+          errors: progress.errors
+        });
+      };
+      const result = await engine.runBenchmark(
+        {
+          defense: defenseName,
+          corpusVersion,
+          categories: categories || getCategoryIds2(),
+          parallel,
+          timeoutMs,
+          seed: Date.now().toString(36)
+        },
+        attackSamples,
+        benignSamples,
+        progressCallback
+      );
+      const evaluator = createDefenseEvaluator();
+      const evaluation = evaluator.evaluate(result);
+      const output = {
+        ...result,
+        score: evaluation.score,
+        metadata: {
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          corpusVersion,
+          adapterVersion: adapter.version
+        }
+      };
+      if (options.output) {
+        const fs = await import("fs");
+        fs.writeFileSync(options.output, JSON.stringify(output, null, 2));
+        logger2.info(`Results written to ${options.output}`);
+      }
+      console.log("\n=== Benchmark Results ===");
+      console.log(`Defense: ${defenseName}`);
+      console.log(`Version: ${adapter.version}`);
+      console.log(`Overall Score: ${(evaluation.score.overallScore * 100).toFixed(1)}%`);
+      console.log(
+        `Attack Success Rate: ${(evaluation.score.attackSuccessRate * 100).toFixed(1)}%`
+      );
+      console.log(
+        `False Positive Rate: ${(evaluation.score.falsePositiveRate * 100).toFixed(1)}%`
+      );
+      console.log(`Avg Latency: ${evaluation.score.avgLatencyMs.toFixed(1)}ms`);
+      console.log(`
+Total Attacks: ${evaluation.overallMetrics.totalAttacks}`);
+      console.log(
+        `Detected: ${evaluation.overallMetrics.totalAttacks - evaluation.overallMetrics.bypassedAttacks}`
+      );
+      console.log(`Bypassed: ${evaluation.overallMetrics.bypassedAttacks}`);
+      await adapter.cleanup?.();
+    } catch (error) {
+      logger2.error("Benchmark failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/compare.command.ts
+import { createLogger as createLogger3 } from "@reaatech/pi-bench-observability";
+import { createDefenseEvaluator as createDefenseEvaluator2 } from "@reaatech/pi-bench-runner";
+import { calculateDefenseScore } from "@reaatech/pi-bench-scoring";
+import { compareMetrics } from "@reaatech/pi-bench-scoring";
+import { Command as Command3 } from "commander";
+var logger3 = createLogger3();
+function createCompareCommand() {
+  const command = new Command3("compare");
+  command.description("Compare multiple defense results").requiredOption("-r, --results <files...>", "Result files to compare").option("-s, --significance <level>", "Statistical significance level", "0.05").option("-o, --output <file>", "Output file for comparison results").action(async (options) => {
+    const resultFiles = options.results;
+    const significanceLevel = Number.parseFloat(options.significance);
+    if (resultFiles.length < 2) {
+      console.error("Error: At least 2 result files are required for comparison");
+      process.exit(1);
+    }
+    logger3.info("Comparing defenses", { files: resultFiles, significance: significanceLevel });
+    try {
+      const results = await Promise.all(
+        resultFiles.map(async (file) => {
+          const fs = await import("fs");
+          const content = fs.readFileSync(file, "utf-8");
+          return JSON.parse(content);
+        })
+      );
+      const comparisons = [];
+      const evaluator = createDefenseEvaluator2();
+      for (let i = 0; i < results.length; i++) {
+        for (let j = i + 1; j < results.length; j++) {
+          const r1 = results[i];
+          const r2 = results[j];
+          if (!r1 || !r2) continue;
+          const defense1Name = r1.defense || r1.defenseName || `Defense ${i + 1}`;
+          const defense2Name = r2.defense || r2.defenseName || `Defense ${j + 1}`;
+          const score1 = r1.score || calculateDefenseScore(r1);
+          const score2 = r2.score || calculateDefenseScore(r2);
+          const comparison2 = evaluator.compare(score1, score2);
+          comparisons.push({
+            defense1: defense1Name,
+            defense2: defense2Name,
+            winner: comparison2.winner,
+            scoreDifference: comparison2.scoreDifference,
+            asrDifference: comparison2.asrDifference,
+            fprDifference: comparison2.fprDifference,
+            categoryWins: comparison2.categoryWins
+          });
+        }
+      }
+      console.log("\n=== Defense Comparison Results ===\n");
+      for (const comp of comparisons) {
+        console.log(`${comp.defense1} vs ${comp.defense2}`);
+        console.log(`  Winner: ${comp.winner}`);
+        console.log(`  Score Difference: ${(comp.scoreDifference * 100).toFixed(1)}%`);
+        console.log(`  ASR Difference: ${(comp.asrDifference * 100).toFixed(1)}%`);
+        console.log(`  FPR Difference: ${(comp.fprDifference * 100).toFixed(1)}%`);
+        console.log("");
+      }
+      const detectionRates = results.map((r) => {
+        const score = r.score || calculateDefenseScore(r);
+        return {
+          detectionRate: 1 - score.attackSuccessRate,
+          falsePositiveRate: score.falsePositiveRate,
+          avgLatencyMs: score.avgLatencyMs,
+          totalAttacks: score.totalSamples,
+          detectedAttacks: 0,
+          bypassedAttacks: 0
+        };
+      });
+      const comparison = compareMetrics(detectionRates, significanceLevel);
+      console.log("=== Statistical Summary ===");
+      console.log(`Significance Level: ${(significanceLevel * 100).toFixed(0)}%`);
+      console.log(`Significant Difference: ${comparison.significantDifference ? "Yes" : "No"}`);
+      console.log("\nRankings (by detection rate):");
+      comparison.rankings.forEach((rank, idx) => {
+        const name = results[rank]?.defense || results[rank]?.defenseName || `Rank ${idx + 1}`;
+        const dr = ((detectionRates[rank]?.detectionRate || 0) * 100).toFixed(1);
+        console.log(`  ${idx + 1}. ${name}: ${dr}% detection rate`);
+      });
+      if (options.output) {
+        const fs = await import("fs");
+        fs.writeFileSync(
+          options.output,
+          JSON.stringify(
+            {
+              comparisons,
+              statisticalSummary: {
+                significanceLevel,
+                significantDifference: comparison.significantDifference,
+                rankings: comparison.rankings.map((rank, idx) => ({
+                  rank: idx + 1,
+                  name: results[rank]?.defense || results[rank]?.defenseName || `Defense ${rank + 1}`,
+                  detectionRate: detectionRates[rank]?.detectionRate || 0
+                }))
+              },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            null,
+            2
+          )
+        );
+        logger3.info(`Comparison results written to ${options.output}`);
+      }
+    } catch (error) {
+      logger3.error("Comparison failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/corpus.command.ts
+import { ATTACK_CATEGORIES } from "@reaatech/pi-bench-core";
+import { createCorpusBuilder, generateDefaultCorpus as generateDefaultCorpus3 } from "@reaatech/pi-bench-corpus";
+import { createCorpusValidator } from "@reaatech/pi-bench-corpus";
+import { createLogger as createLogger4 } from "@reaatech/pi-bench-observability";
+import { Command as Command4 } from "commander";
+var logger4 = createLogger4();
+function createCorpusCommand() {
+  const command = new Command4("corpus");
+  command.description("Manage test corpus");
+  command.command("list").description("List available corpus versions and categories").action(async () => {
+    console.log("=== Attack Categories ===\n");
+    for (const cat of ATTACK_CATEGORIES) {
+      console.log(`  ${cat.id}`);
+      console.log(`    Name: ${cat.name}`);
+      console.log(`    Weight: ${cat.weight}`);
+      console.log(`    Min Samples: ${cat.minSamples}`);
+      console.log(`    Description: ${cat.description}`);
+      console.log("");
+    }
+    console.log("=== Available Corpus Versions ===\n");
+    console.log("  2026.04 (current)");
+    console.log("    Total samples: ~300");
+    console.log("    Categories: 8");
+    console.log("    Last updated: 2026-04-01");
+    console.log("");
+    console.log("  2026.01 (deprecated)");
+    console.log("    Total samples: ~250");
+    console.log("    Categories: 6");
+    console.log("    Last updated: 2026-01-15");
+  });
+  command.command("generate").description("Generate a new corpus version").option("-o, --output <dir>", "Output directory for corpus", "./corpus/generated").option("-v, --version <version>", "Corpus version string", `v${Date.now().toString(36)}`).option("-s, --samples <number>", "Samples per category", "40").action(async (options) => {
+    const outputDir = options.output;
+    const version = options.version;
+    const samplesPerCategory = Number.parseInt(options.samples, 10);
+    logger4.info("Generating corpus", { version, outputDir, samplesPerCategory });
+    try {
+      const builder = createCorpusBuilder({
+        version,
+        samplesPerCategory
+      });
+      const corpus = generateDefaultCorpus3();
+      builder.addSamples(corpus);
+      const validator = createCorpusValidator();
+      const validation = validator.validate(corpus);
+      console.log("\n=== Corpus Generation Complete ===\n");
+      console.log(`Version: ${version}`);
+      console.log(`Total Samples: ${corpus.length}`);
+      console.log(`Output Directory: ${outputDir}`);
+      if (!validation.valid) {
+        console.log("\nValidation Errors:");
+        for (const e of validation.errors) {
+          console.log(`  - ${e}`);
+        }
+      }
+      if (validation.warnings.length > 0) {
+        console.log("\nWarnings:");
+        for (const w of validation.warnings) {
+          console.log(`  - ${w}`);
+        }
+      }
+      console.log("\nStatistics:");
+      console.log(`  Unique Prompts: ${validation.stats.uniquePrompts}`);
+      console.log(`  Duplicates: ${validation.stats.duplicateCount}`);
+      console.log("  Category Distribution:");
+      for (const [cat, count] of Object.entries(validation.stats.categoryDistribution)) {
+        console.log(`    ${cat}: ${count}`);
+      }
+      if (outputDir !== "./corpus/generated") {
+        console.log(`
+Note: Writing to ${outputDir} requires file system access.`);
+        console.log("Generated corpus is available in memory for immediate use.");
+      }
+    } catch (error) {
+      logger4.error("Corpus generation failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+  command.command("validate").description("Validate a corpus").requiredOption("-i, --input <dir>", "Corpus directory to validate").action(async (options) => {
+    const inputDir = options.input;
+    logger4.info("Validating corpus", { input: inputDir });
+    console.log("\n=== Corpus Validation ===\n");
+    console.log(`Input: ${inputDir}`);
+    try {
+      const fs = await import("fs");
+      if (!fs.existsSync(inputDir)) {
+        console.log("Error: Directory does not exist");
+        process.exit(1);
+      }
+      const files = fs.readdirSync(inputDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".json"));
+      if (files.length === 0) {
+        console.log("Warning: No corpus files (.yaml or .json) found in directory");
+        return;
+      }
+      let totalSamples = 0;
+      const categoryStats = {};
+      for (const file of files) {
+        const content = fs.readFileSync(`${inputDir}/${file}`, "utf-8");
+        const data = file.endsWith(".json") ? JSON.parse(content) : await import("yaml").then((y) => y.parse(content));
+        const samples = Array.isArray(data) ? data : data.samples || [];
+        totalSamples += samples.length;
+        for (const sample of samples) {
+          const cat = sample.category || "unknown";
+          categoryStats[cat] = (categoryStats[cat] || 0) + 1;
+        }
+      }
+      console.log(`
+Total Samples: ${totalSamples}`);
+      console.log("\nCategory Distribution:");
+      for (const [cat, count] of Object.entries(categoryStats)) {
+        console.log(`  ${cat}: ${count}`);
+      }
+      if (Object.keys(categoryStats).length < 8) {
+        console.log("\nWarning: Not all 8 categories are represented in the corpus");
+      }
+    } catch (error) {
+      logger4.error("Validation failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+  command.command("export").description("Export corpus to a specific format").requiredOption("-i, --input <dir>", "Corpus directory").option("-f, --format <format>", "Output format (json, yaml, csv)", "json").option("-o, --output <file>", "Output file (default: stdout)").action(async (options) => {
+    const inputDir = options.input;
+    const format = options.format;
+    const outputFile = options.output;
+    logger4.info("Exporting corpus", { input: inputDir, format, output: outputFile || "stdout" });
+    console.log("\n=== Corpus Export ===\n");
+    console.log(`Format: ${format}`);
+    console.log(`Source: ${inputDir}`);
+    if (outputFile) {
+      console.log(`Output: ${outputFile}`);
+      console.log("\nExport functionality requires file system access.");
+    } else {
+      console.log("\nExporting to stdout...");
+      const corpus = generateDefaultCorpus3();
+      if (format === "json") {
+        console.log(JSON.stringify(corpus, null, 2));
+      } else if (format === "yaml") {
+        const yaml = await import("yaml");
+        console.log(yaml.stringify(corpus));
+      } else if (format === "csv") {
+        console.log("id,category,severity,prompt,tags");
+        for (const sample of corpus) {
+          const escapedPrompt = sample.prompt.replace(/"/g, '""');
+          console.log(
+            `${sample.id},${sample.category},${sample.severity},"${escapedPrompt}","${sample.tags.join(";")}"`
+          );
+        }
+      }
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/leaderboard.command.ts
+import { DefenseScoreSchema } from "@reaatech/pi-bench-core";
+import { createLeaderboardManager } from "@reaatech/pi-bench-leaderboard";
+import {
+  getDefaultLeaderboardPath,
+  loadLeaderboardEntries,
+  saveLeaderboardEntries
+} from "@reaatech/pi-bench-leaderboard";
+import { createLogger as createLogger5 } from "@reaatech/pi-bench-observability";
+import { Command as Command5 } from "commander";
+var logger5 = createLogger5();
+function createLeaderboardCommand() {
+  const command = new Command5("leaderboard");
+  command.description("View/submit to leaderboard");
+  command.command("view").description("View current leaderboard rankings").option("-c, --category <category>", "Filter by attack category").option("-n, --limit <number>", "Number of entries to show", "10").option("--file <path>", "Leaderboard storage file", getDefaultLeaderboardPath()).action(async (options) => {
+    const limit = Number.parseInt(options.limit, 10);
+    const category = options.category;
+    const manager = createLeaderboardManager();
+    manager.replaceEntries(loadLeaderboardEntries(options.file));
+    const entries = category ? manager.getRankings(manager.getEntryCount() || limit).filter((e) => e.categoryScores && category in e.categoryScores) : manager.getRankings(limit);
+    console.log("\n=== Prompt Injection Defense Leaderboard ===\n");
+    console.log("Rank | Defense | Version | Overall Score | Submitted");
+    console.log("-----|---------|---------|---------------|----------");
+    entries.slice(0, limit).forEach((entry, idx) => {
+      const date = new Date(entry.submittedAt).toLocaleDateString();
+      console.log(
+        `${`${idx + 1}    | ${entry.defense.padEnd(12)} | ${entry.version.padEnd(7)} | ${(entry.overallScore * 100).toFixed(1)}%`.padEnd(
+          40
+        )} | ${date}`
+      );
+    });
+    if (entries.length === 0) {
+      console.log("No entries found.");
+    }
+    console.log("\n");
+    console.log(`Storage: ${options.file}`);
+    console.log("Submit a local entry with:");
+    console.log("  prompt-injection-bench leaderboard submit -r results.json --defense <name>");
+  });
+  command.command("submit").description("Submit results to the leaderboard").requiredOption("-r, --results <file>", "Results file to submit").requiredOption("--defense <name>", "Defense name").option("--defense-version <version>", "Defense version").option("--seed <seed>", "Random seed used for the run").option("--private", "Submit as private (not publicly visible)").option("--file <path>", "Leaderboard storage file", getDefaultLeaderboardPath()).action(async (options) => {
+    const resultsFile = options.results;
+    const defenseName = options.defense;
+    const defenseVersion = options.defenseVersion;
+    const seed = options.seed;
+    logger5.info("Submitting to leaderboard", { defense: defenseName, version: defenseVersion });
+    try {
+      const fs = await import("fs");
+      const content = fs.readFileSync(resultsFile, "utf-8");
+      const results = JSON.parse(content);
+      const score = resolveScore(results);
+      const entry = {
+        defense: defenseName,
+        version: defenseVersion || score.version,
+        overallScore: score.overallScore,
+        rank: 0,
+        submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        corpusVersion: results.corpusVersion || results.metadata?.corpusVersion || "2026.04",
+        categoryScores: mapCategoryScores(score),
+        proofHash: seed || `local-${Date.now().toString(36)}`,
+        submitter: options.private ? "anonymous" : "local-user"
+      };
+      const manager = createLeaderboardManager();
+      manager.replaceEntries(loadLeaderboardEntries(options.file));
+      manager.addEntry(entry);
+      saveLeaderboardEntries(manager.getAllEntries(), options.file);
+      console.log("\n=== Submission Successful ===");
+      console.log(`Defense: ${entry.defense}`);
+      console.log(`Version: ${entry.version}`);
+      console.log(`Overall Score: ${(entry.overallScore * 100).toFixed(1)}%`);
+      console.log(`Proof Hash: ${entry.proofHash}`);
+      console.log(`Stored at: ${options.file}`);
+    } catch (error) {
+      logger5.error("Submission failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+  command.command("verify").description("Verify a submission").requiredOption("--id <id>", "Submission proof hash to verify").option("--file <path>", "Leaderboard storage file", getDefaultLeaderboardPath()).action(async (options) => {
+    const submissionId = options.id;
+    const manager = createLeaderboardManager();
+    manager.replaceEntries(loadLeaderboardEntries(options.file));
+    const found = manager.getAllEntries().find((entry) => entry.proofHash === submissionId);
+    console.log("\n=== Verifying Submission ===");
+    console.log(`Submission ID: ${submissionId}`);
+    console.log("");
+    if (!found) {
+      console.log("Status: not found");
+      console.log(`Storage: ${options.file}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log("Status: verified");
+    console.log(`Defense: ${found.defense}`);
+    console.log(`Version: ${found.version}`);
+    console.log(`Overall Score: ${(found.overallScore * 100).toFixed(1)}%`);
+    console.log(`Submitted: ${found.submittedAt}`);
+    console.log(`Storage: ${options.file}`);
+  });
+  return command;
+}
+function resolveScore(results) {
+  if (results.score && typeof results.score === "object") {
+    return DefenseScoreSchema.parse(results.score);
+  }
+  return DefenseScoreSchema.parse(results);
+}
+function mapCategoryScores(score) {
+  return Object.fromEntries(
+    Object.entries(score.categoryScores).map(([category, value]) => [
+      category,
+      value.detectionRate
+    ])
+  );
+}
+
+// src/cli/commands/report.command.ts
+import { normalizeReportData } from "@reaatech/pi-bench-mcp-server";
+import { Command as Command6 } from "commander";
+function createReportCommand() {
+  const command = new Command6("report");
+  command.description("Generate reports from benchmark results").requiredOption("-r, --results <file>", "Results file to generate report from").option("-f, --format <format>", "Output format (json, html, markdown)", "json").option("-o, --output <file>", "Output file").option("--include-categories", "Include category breakdown", true).action(async (options) => {
+    const resultsFile = options.results;
+    const format = options.format;
+    const outputFile = options.output || `report.${format}`;
+    const includeCategories = options.includeCategories;
+    console.log(`Generating ${format} report from: ${resultsFile}`);
+    const fs = await import("fs");
+    const results = JSON.parse(fs.readFileSync(resultsFile, "utf-8"));
+    const reportData = normalizeReportData(results);
+    let report;
+    if (format === "json") {
+      report = JSON.stringify(reportData, null, 2);
+    } else if (format === "markdown") {
+      report = generateMarkdownReport(reportData, includeCategories);
+    } else if (format === "html") {
+      report = generateHtmlReport(reportData, includeCategories);
+    } else {
+      console.error(`Unsupported format: ${format}`);
+      process.exit(1);
+    }
+    fs.writeFileSync(outputFile, report);
+    console.log(`
+Report generated: ${outputFile}`);
+  });
+  return command;
+}
+function generateMarkdownReport(r, includeCategories) {
+  let md = "# Prompt Injection Benchmark Report\n\n";
+  md += `Generated: ${r.generatedAt || (/* @__PURE__ */ new Date()).toISOString()}
+
+`;
+  if (r.defense) {
+    md += `Defense: ${r.defense}${r.version ? ` (${r.version})` : ""}
+
+`;
+  }
+  md += "## Summary\n\n";
+  md += "| Metric | Value |\n|--------|-------|\n";
+  md += `| Detection Rate | ${(r.detectionRate * 100).toFixed(1)}% |
+`;
+  md += `| False Positive Rate | ${(r.falsePositiveRate * 100).toFixed(1)}% |
+`;
+  md += `| Total Attacks | ${r.totalAttacks} |
+`;
+  md += `| Avg Latency | ${r.avgLatencyMs.toFixed(1)}ms |
+`;
+  if (includeCategories && Object.keys(r.categoryBreakdown).length > 0) {
+    md += "\n## Category Breakdown\n\n";
+    md += "| Category | Detection Rate | Attacks |\n|----------|----------------|---------|\n";
+    for (const [category, data] of Object.entries(r.categoryBreakdown)) {
+      md += `| ${category} | ${(data.detectionRate * 100).toFixed(1)}% | ${data.totalAttacks} |
+`;
+    }
+  }
+  return md;
+}
+function generateHtmlReport(r, includeCategories) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Prompt Injection Benchmark Report</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 40px auto; padding: 0 20px; }
+    h1 { color: #333; }
+    table { border-collapse: collapse; width: 100%; margin: 20px 0; }
+    th, td { border: 1px solid #ddd; padding: 12px; text-align: left; }
+    th { background: #f5f5f5; }
+    .metric { display: inline-block; margin: 10px 20px 10px 0; padding: 15px 25px; background: #f8f9fa; border-radius: 8px; }
+    .metric-value { font-size: 24px; font-weight: bold; color: #007bff; }
+    .metric-label { font-size: 12px; color: #666; text-transform: uppercase; }
+  </style>
+</head>
+<body>
+  <h1>Prompt Injection Benchmark Report</h1>
+  <p>Generated: ${r.generatedAt || (/* @__PURE__ */ new Date()).toISOString()}</p>
+  ${r.defense ? `<p>Defense: ${r.defense}${r.version ? ` (${r.version})` : ""}</p>` : ""}
+
+  <h2>Summary</h2>
+  <div class="metric">
+    <div class="metric-value">${(r.detectionRate * 100).toFixed(1)}%</div>
+    <div class="metric-label">Detection Rate</div>
+  </div>
+  <div class="metric">
+    <div class="metric-value">${(r.falsePositiveRate * 100).toFixed(1)}%</div>
+    <div class="metric-label">False Positive Rate</div>
+  </div>
+  <div class="metric">
+    <div class="metric-value">${r.totalAttacks}</div>
+    <div class="metric-label">Total Attacks</div>
+  </div>
+  <div class="metric">
+    <div class="metric-value">${r.avgLatencyMs.toFixed(1)}ms</div>
+    <div class="metric-label">Avg Latency</div>
+  </div>
+
+  ${includeCategories && Object.keys(r.categoryBreakdown).length > 0 ? `
+  <h2>Category Breakdown</h2>
+  <table>
+    <tr><th>Category</th><th>Detection Rate</th><th>Attacks</th></tr>
+    ${Object.entries(r.categoryBreakdown).map(
+    ([category, data]) => `<tr><td>${category}</td><td>${(data.detectionRate * 100).toFixed(1)}%</td><td>${data.totalAttacks}</td></tr>`
+  ).join("")}
+  </table>
+  ` : ""}
+</body>
+</html>`;
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command7();
+program.name("prompt-injection-bench").description(pkg.description).version(pkg.version);
+program.addCommand(createBenchmarkCommand());
+program.addCommand(createAttackCommand());
+program.addCommand(createCompareCommand());
+program.addCommand(createCorpusCommand());
+program.addCommand(createLeaderboardCommand());
+program.addCommand(createReportCommand());
+program.parse();