@rahul-sch/vibeguard 1.0.0

package/dist/cli/commands/scan.js

@@ -0,0 +1,54 @@
+import { resolve } from 'node:path';
+import { scan } from '../../engine/index.js';
+import { resolveConfig } from '../../config/index.js';
+import { createReporter } from '../../reporters/index.js';
+import { verifyFindings, detectProvider } from '../../ai/index.js';
+import { ruleById } from '../../rules/index.js';
+export async function scanCommand(targetPath = '.', options) {
+    const resolvedPath = resolve(targetPath);
+    // Handle --no-color (commander sets color: false)
+    if (options.color === false) {
+        options.noColor = true;
+    }
+    const config = resolveConfig(resolvedPath, options);
+    if (config.verbose) {
+        console.error(`VibeGuard scanning: ${config.targetPath}`);
+        console.error(`Ignore patterns: ${config.ignorePatterns.length}`);
+        console.error(`Max file size: ${config.maxFileSize}`);
+        console.error(`Severities: ${config.includeSeverities.join(', ')}`);
+        console.error(`Format: ${config.format}`);
+        console.error(`AI verification: ${config.aiVerify ? 'enabled' : 'disabled'}`);
+    }
+    let result = await scan(config);
+    // AI verification if enabled and API key available
+    if (config.aiVerify && config.aiApiKey) {
+        if (config.verbose) {
+            console.error(`Running AI verification with ${config.aiProvider || 'auto-detected'} provider...`);
+        }
+        const provider = config.aiProvider || detectProvider(config.aiApiKey);
+        const verifiedFindings = await verifyFindings(result.findings, ruleById, {
+            provider,
+            apiKey: config.aiApiKey,
+        }, config.verbose);
+        result = {
+            ...result,
+            findings: verifiedFindings,
+        };
+    }
+    else if (config.aiVerify && !config.aiApiKey) {
+        console.error('Warning: --ai flag set but no API key found. Set VIBEGUARD_AI_KEY or use --ai-key.');
+    }
+    const reporter = createReporter(config.format, config.noColor);
+    const output = reporter.report(result);
+    console.log(output);
+    // Exit codes: 0 = clean/info only, 1 = warnings, 2 = critical
+    if (result.criticalCount > 0) {
+        process.exitCode = 2;
+    }
+    else if (result.warningCount > 0) {
+        process.exitCode = 1;
+    }
+    else {
+        process.exitCode = 0;
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/index.js

@@ -0,0 +1,49 @@
+import { Command } from 'commander';
+import { VERSION, NAME } from '../index.js';
+import { scanCommand } from './commands/scan.js';
+import { fixCommand } from './commands/fix.js';
+import { githubCommand } from './commands/github.js';
+import { severityOption, formatOption, jsonOption, sarifOption, ignoreOption, maxFileSizeOption, noColorOption, verboseOption, configOption, aiOption, aiKeyOption, aiProviderOption, dryRunOption, yesOption, gitOption, } from './options.js';
+const program = new Command();
+program
+    .name(NAME)
+    .version(VERSION)
+    .description('Regex-first security scanner for AI-generated code');
+program
+    .command('scan', { isDefault: true })
+    .description('Scan a directory for security issues')
+    .argument('[path]', 'directory to scan', '.')
+    .addOption(severityOption)
+    .addOption(formatOption)
+    .addOption(jsonOption)
+    .addOption(sarifOption)
+    .addOption(ignoreOption)
+    .addOption(maxFileSizeOption)
+    .addOption(noColorOption)
+    .addOption(verboseOption)
+    .addOption(configOption)
+    .addOption(aiOption)
+    .addOption(aiKeyOption)
+    .addOption(aiProviderOption)
+    .action(scanCommand);
+program
+    .command('fix')
+    .description('Auto-fix security issues in code')
+    .argument('[path]', 'directory to fix', '.')
+    .addOption(severityOption)
+    .addOption(dryRunOption)
+    .addOption(yesOption)
+    .addOption(gitOption)
+    .addOption(verboseOption)
+    .addOption(configOption)
+    .action(fixCommand);
+program
+    .command('github')
+    .description('GitHub integration commands')
+    .argument('<action>', 'install')
+    .argument('[path]', 'project directory', '.')
+    .option('--no-auto-fix', 'disable automatic fixes on approval')
+    .option('--severity <level>', 'minimum severity to report', 'warning')
+    .option('--ai-verify', 'enable AI verification')
+    .action(githubCommand);
+program.parse();

package/dist/cli/options.d.ts

@@ -0,0 +1,17 @@
+import { Option } from 'commander';
+export declare const severityOption: Option;
+export declare const formatOption: Option;
+export declare const jsonOption: Option;
+export declare const sarifOption: Option;
+export declare const ignoreOption: Option;
+export declare const maxFileSizeOption: Option;
+export declare const noColorOption: Option;
+export declare const verboseOption: Option;
+export declare const aiOption: Option;
+export declare const noAiOption: Option;
+export declare const aiKeyOption: Option;
+export declare const aiProviderOption: Option;
+export declare const configOption: Option;
+export declare const dryRunOption: Option;
+export declare const yesOption: Option;
+export declare const gitOption: Option;

package/dist/cli/options.js

@@ -0,0 +1,27 @@
+import { Option } from 'commander';
+import { validateSeverity, validateFormat, validateMaxFileSize } from '../config/schema.js';
+export const severityOption = new Option('-s, --severity <level>', 'minimum severity level to report')
+    .choices(['critical', 'warning', 'info'])
+    .default('warning')
+    .argParser(validateSeverity);
+export const formatOption = new Option('-f, --format <type>', 'output format')
+    .choices(['console', 'json', 'sarif'])
+    .default('console')
+    .argParser(validateFormat);
+export const jsonOption = new Option('--json', 'shorthand for --format json');
+export const sarifOption = new Option('--sarif', 'shorthand for --format sarif');
+export const ignoreOption = new Option('-i, --ignore <pattern>', 'additional ignore patterns (can be repeated)');
+export const maxFileSizeOption = new Option('--max-file-size <bytes>', 'skip files larger than this size')
+    .default('1048576')
+    .argParser(validateMaxFileSize);
+export const noColorOption = new Option('--no-color', 'disable colored output');
+export const verboseOption = new Option('-v, --verbose', 'show debug information');
+export const aiOption = new Option('--ai', 'enable AI verification for flagged rules');
+export const noAiOption = new Option('--no-ai', 'disable AI verification');
+export const aiKeyOption = new Option('--ai-key <key>', 'API key for AI provider');
+export const aiProviderOption = new Option('--ai-provider <name>', 'AI provider: openai, anthropic, groq').choices(['openai', 'anthropic', 'groq']);
+export const configOption = new Option('-c, --config <path>', 'path to config file');
+// Fix command options
+export const dryRunOption = new Option('--dry-run', 'show diffs without applying changes');
+export const yesOption = new Option('-y, --yes', 'apply fixes without prompting for confirmation');
+export const gitOption = new Option('--git', 'stage fixed files with git add');

package/dist/config/defaults.d.ts

@@ -0,0 +1,17 @@
+import type { RuleSeverity } from '../rules/types.js';
+import type { ReporterType } from '../reporters/types.js';
+export interface VibeGuardConfig {
+    targetPath: string;
+    ignorePatterns: string[];
+    maxFileSize: number;
+    includeSeverities: RuleSeverity[];
+    ruleIds?: string[];
+    format: ReporterType;
+    noColor: boolean;
+    verbose: boolean;
+    aiVerify: boolean;
+    aiProvider?: string;
+    aiApiKey?: string;
+}
+export declare const DEFAULT_CONFIG: VibeGuardConfig;
+export declare const DEFAULT_IGNORE_PATTERNS: string[];

package/dist/config/defaults.js

@@ -0,0 +1,21 @@
+export const DEFAULT_CONFIG = {
+    targetPath: '.',
+    ignorePatterns: [],
+    maxFileSize: 1024 * 1024, // 1MB
+    includeSeverities: ['critical', 'warning'],
+    format: 'console',
+    noColor: false,
+    verbose: false,
+    aiVerify: false,
+};
+export const DEFAULT_IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/.next/**',
+    '**/build/**',
+    '**/coverage/**',
+    '**/.venv/**',
+    '**/__pycache__/**',
+    '**/vendor/**',
+];

package/dist/config/index.d.ts

@@ -0,0 +1,17 @@
+import type { VibeGuardConfig } from './defaults.js';
+export interface CLIOptions {
+    severity?: string;
+    format?: string;
+    json?: boolean;
+    sarif?: boolean;
+    ignore?: string[];
+    maxFileSize?: string;
+    noColor?: boolean;
+    verbose?: boolean;
+    ai?: boolean;
+    aiKey?: string;
+    aiProvider?: string;
+    config?: string;
+}
+export declare function resolveConfig(targetPath: string, cliOptions?: CLIOptions): VibeGuardConfig;
+export { type VibeGuardConfig, DEFAULT_CONFIG, DEFAULT_IGNORE_PATTERNS } from './defaults.js';

package/dist/config/index.js

@@ -0,0 +1,119 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { DEFAULT_CONFIG, DEFAULT_IGNORE_PATTERNS } from './defaults.js';
+import { parseSeverities, validateFormat } from './schema.js';
+const CONFIG_FILENAMES = [
+    'vibeguard.config.js',
+    'vibeguard.config.mjs',
+    'vibeguard.config.json',
+    '.vibeguardrc',
+    '.vibeguardrc.json',
+];
+function findConfigFile(startDir) {
+    let currentDir = resolve(startDir);
+    const root = dirname(currentDir);
+    while (currentDir !== root) {
+        for (const filename of CONFIG_FILENAMES) {
+            const configPath = resolve(currentDir, filename);
+            if (existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        const parent = dirname(currentDir);
+        if (parent === currentDir)
+            break;
+        currentDir = parent;
+    }
+    return null;
+}
+function loadConfigFile(configPath) {
+    const content = readFileSync(configPath, 'utf-8');
+    if (configPath.endsWith('.json') || configPath.endsWith('.vibeguardrc')) {
+        return JSON.parse(content);
+    }
+    // For JS/MJS files, we'd need dynamic import - skip for MVP
+    return {};
+}
+export function resolveConfig(targetPath, cliOptions = {}) {
+    // Start with defaults
+    const config = { ...DEFAULT_CONFIG };
+    config.targetPath = resolve(targetPath);
+    config.ignorePatterns = [...DEFAULT_IGNORE_PATTERNS];
+    // Load config file if exists
+    const configPath = cliOptions.config || findConfigFile(targetPath);
+    if (configPath && existsSync(configPath)) {
+        const fileConfig = loadConfigFile(configPath);
+        if (fileConfig.ignore) {
+            config.ignorePatterns.push(...fileConfig.ignore);
+        }
+        if (fileConfig.maxFileSize !== undefined) {
+            config.maxFileSize = fileConfig.maxFileSize;
+        }
+        if (fileConfig.severity) {
+            config.includeSeverities = parseSeverities(fileConfig.severity);
+        }
+        if (fileConfig.rules) {
+            config.ruleIds = fileConfig.rules;
+        }
+        if (fileConfig.format) {
+            config.format = validateFormat(fileConfig.format);
+        }
+        if (fileConfig.noColor !== undefined) {
+            config.noColor = fileConfig.noColor;
+        }
+        if (fileConfig.verbose !== undefined) {
+            config.verbose = fileConfig.verbose;
+        }
+        if (fileConfig.ai !== undefined) {
+            config.aiVerify = fileConfig.ai;
+        }
+        if (fileConfig.aiProvider) {
+            config.aiProvider = fileConfig.aiProvider;
+        }
+        if (fileConfig.aiApiKey) {
+            config.aiApiKey = fileConfig.aiApiKey;
+        }
+    }
+    // CLI options override everything
+    if (cliOptions.ignore) {
+        config.ignorePatterns.push(...cliOptions.ignore);
+    }
+    if (cliOptions.maxFileSize) {
+        config.maxFileSize = parseInt(cliOptions.maxFileSize, 10);
+    }
+    if (cliOptions.severity) {
+        config.includeSeverities = parseSeverities(cliOptions.severity);
+    }
+    if (cliOptions.json) {
+        config.format = 'json';
+    }
+    else if (cliOptions.sarif) {
+        config.format = 'sarif';
+    }
+    else if (cliOptions.format) {
+        config.format = validateFormat(cliOptions.format);
+    }
+    if (cliOptions.noColor) {
+        config.noColor = true;
+    }
+    if (cliOptions.verbose) {
+        config.verbose = true;
+    }
+    if (cliOptions.ai !== undefined) {
+        config.aiVerify = cliOptions.ai;
+    }
+    if (cliOptions.aiKey) {
+        config.aiApiKey = cliOptions.aiKey;
+    }
+    if (cliOptions.aiProvider) {
+        config.aiProvider = cliOptions.aiProvider;
+    }
+    // Env vars for AI key
+    if (!config.aiApiKey) {
+        config.aiApiKey = process.env.VIBEGUARD_AI_KEY ||
+            process.env.OPENAI_API_KEY ||
+            process.env.ANTHROPIC_API_KEY;
+    }
+    return config;
+}
+export { DEFAULT_CONFIG, DEFAULT_IGNORE_PATTERNS } from './defaults.js';

package/dist/config/schema.d.ts

@@ -0,0 +1,20 @@
+import type { RuleSeverity } from '../rules/types.js';
+import type { ReporterType } from '../reporters/types.js';
+export interface ConfigFileSchema {
+    targetPath?: string;
+    ignore?: string[];
+    maxFileSize?: number;
+    severity?: RuleSeverity | RuleSeverity[];
+    rules?: string[];
+    format?: ReporterType;
+    noColor?: boolean;
+    verbose?: boolean;
+    ai?: boolean;
+    aiProvider?: string;
+    aiApiKey?: string;
+}
+export declare function validateSeverity(value: string): RuleSeverity;
+export declare function validateFormat(value: string): ReporterType;
+export declare function validateMaxFileSize(value: string): number;
+export declare function severitiesAtOrAbove(minSeverity: RuleSeverity): RuleSeverity[];
+export declare function parseSeverities(input: string | string[]): RuleSeverity[];

package/dist/config/schema.js

@@ -0,0 +1,39 @@
+export function validateSeverity(value) {
+    const valid = ['critical', 'warning', 'info'];
+    if (!valid.includes(value)) {
+        throw new Error(`Invalid severity: ${value}. Must be one of: ${valid.join(', ')}`);
+    }
+    return value;
+}
+export function validateFormat(value) {
+    const valid = ['console', 'json', 'sarif'];
+    if (!valid.includes(value)) {
+        throw new Error(`Invalid format: ${value}. Must be one of: ${valid.join(', ')}`);
+    }
+    return value;
+}
+export function validateMaxFileSize(value) {
+    const num = parseInt(value, 10);
+    if (isNaN(num) || num <= 0) {
+        throw new Error(`Invalid max-file-size: ${value}. Must be a positive number.`);
+    }
+    return num;
+}
+// Severity hierarchy: critical > warning > info
+const SEVERITY_LEVELS = {
+    critical: 3,
+    warning: 2,
+    info: 1,
+};
+export function severitiesAtOrAbove(minSeverity) {
+    const minLevel = SEVERITY_LEVELS[minSeverity];
+    return ['critical', 'warning', 'info'].filter((s) => SEVERITY_LEVELS[s] >= minLevel);
+}
+export function parseSeverities(input) {
+    // If single severity, treat as minimum (include this and above)
+    if (typeof input === 'string') {
+        return severitiesAtOrAbove(validateSeverity(input));
+    }
+    // If array, use exact list
+    return input.map(validateSeverity);
+}

package/dist/engine/file-walker.d.ts

@@ -0,0 +1,12 @@
+export interface FileEntry {
+    path: string;
+    relativePath: string;
+    size: number;
+}
+export interface WalkerOptions {
+    targetPath: string;
+    ignorePatterns: string[];
+    maxFileSize: number;
+}
+export declare function walkFiles(options: WalkerOptions): Promise<FileEntry[]>;
+export declare function readFileContent(filePath: string, maxSize: number): Promise<string | null>;

package/dist/engine/file-walker.js

@@ -0,0 +1,61 @@
+import fg from 'fast-glob';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { isBinaryBuffer } from '../utils/binary-check.js';
+const DEFAULT_IGNORE = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/.next/**',
+    '**/build/**',
+    '**/coverage/**',
+    '**/.venv/**',
+    '**/__pycache__/**',
+    '**/vendor/**',
+    '**/*.min.js',
+    '**/*.bundle.js',
+    '**/*.map',
+    '**/package-lock.json',
+    '**/yarn.lock',
+    '**/pnpm-lock.yaml',
+];
+export async function walkFiles(options) {
+    const { targetPath, ignorePatterns, maxFileSize } = options;
+    const allIgnore = [...DEFAULT_IGNORE, ...ignorePatterns];
+    const entries = await fg(['**/*'], {
+        cwd: targetPath,
+        ignore: allIgnore,
+        onlyFiles: true,
+        dot: false,
+        absolute: false,
+        stats: true,
+    });
+    const files = [];
+    for (const entry of entries) {
+        const stats = entry.stats;
+        if (!stats || stats.size > maxFileSize) {
+            continue;
+        }
+        files.push({
+            path: path.join(targetPath, entry.path),
+            relativePath: entry.path,
+            size: stats.size,
+        });
+    }
+    return files;
+}
+export async function readFileContent(filePath, maxSize) {
+    try {
+        const buffer = await fs.readFile(filePath);
+        if (buffer.length > maxSize) {
+            return null;
+        }
+        if (isBinaryBuffer(buffer)) {
+            return null;
+        }
+        return buffer.toString('utf-8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/engine/filter.d.ts

@@ -0,0 +1,3 @@
+import type { Language, DetectionRule } from '../rules/types.js';
+export declare function detectLanguages(filePath: string): Language[];
+export declare function filterRulesForFile(filePath: string, allRules: DetectionRule[]): DetectionRule[];

package/dist/engine/filter.js

@@ -0,0 +1,50 @@
+import * as path from 'path';
+const extensionMap = {
+    '.py': ['python'],
+    '.js': ['node'],
+    '.ts': ['node', 'typescript'],
+    '.tsx': ['node', 'typescript'],
+    '.jsx': ['node'],
+    '.mjs': ['node'],
+    '.cjs': ['node'],
+    '.yaml': ['yaml', 'kubernetes'],
+    '.yml': ['yaml', 'kubernetes'],
+    '.json': ['json'],
+};
+export function detectLanguages(filePath) {
+    const basename = path.basename(filePath).toLowerCase();
+    if (basename === 'dockerfile' || basename.endsWith('.dockerfile')) {
+        return ['docker'];
+    }
+    if (basename === 'docker-compose.yml' || basename === 'docker-compose.yaml') {
+        return ['docker', 'yaml'];
+    }
+    if (basename.includes('k8s') ||
+        basename.includes('kubernetes') ||
+        basename.includes('deployment') ||
+        basename.includes('service') ||
+        basename.includes('ingress')) {
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext === '.yml' || ext === '.yaml') {
+            return ['kubernetes', 'yaml'];
+        }
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    return extensionMap[ext] || [];
+}
+export function filterRulesForFile(filePath, allRules) {
+    const basename = path.basename(filePath);
+    const languages = detectLanguages(filePath);
+    return allRules.filter((rule) => {
+        const langMatch = rule.languages.some((lang) => languages.includes(lang));
+        if (!langMatch)
+            return false;
+        const patternMatch = rule.filePatterns.some((pattern) => {
+            if (pattern.startsWith('*')) {
+                return basename.endsWith(pattern.slice(1));
+            }
+            return basename === pattern || basename.toLowerCase() === pattern.toLowerCase();
+        });
+        return patternMatch;
+    });
+}

package/dist/engine/index.d.ts

@@ -0,0 +1,10 @@
+import type { ScanResult, RuleSeverity } from '../rules/types.js';
+export interface ScanOptions {
+    targetPath: string;
+    ignorePatterns?: string[];
+    maxFileSize?: number;
+    includeSeverities?: RuleSeverity[];
+    ruleIds?: string[];
+}
+export declare function scan(options: ScanOptions): Promise<ScanResult>;
+export { allRules } from '../rules/index.js';

package/dist/engine/index.js

@@ -0,0 +1,54 @@
+import { allRules } from '../rules/index.js';
+import { walkFiles, readFileContent } from './file-walker.js';
+import { filterRulesForFile } from './filter.js';
+import { matchRule, createFinding } from './matcher.js';
+const DEFAULT_MAX_FILE_SIZE = 1024 * 1024; // 1MB
+export async function scan(options) {
+    const startTime = Date.now();
+    const { targetPath, ignorePatterns = [], maxFileSize = DEFAULT_MAX_FILE_SIZE, includeSeverities = ['critical', 'warning'], ruleIds, } = options;
+    let rulesToRun = allRules;
+    if (ruleIds && ruleIds.length > 0) {
+        rulesToRun = allRules.filter((r) => ruleIds.includes(r.id));
+    }
+    if (includeSeverities.length > 0) {
+        rulesToRun = rulesToRun.filter((r) => includeSeverities.includes(r.severity));
+    }
+    const files = await walkFiles({
+        targetPath,
+        ignorePatterns,
+        maxFileSize,
+    });
+    const findings = [];
+    let scannedFiles = 0;
+    let skippedFiles = 0;
+    for (const file of files) {
+        const content = await readFileContent(file.path, maxFileSize);
+        if (content === null) {
+            skippedFiles++;
+            continue;
+        }
+        scannedFiles++;
+        const applicableRules = filterRulesForFile(file.relativePath, rulesToRun);
+        for (const rule of applicableRules) {
+            const matches = matchRule(content, rule);
+            for (const match of matches) {
+                findings.push(createFinding(rule, match, file.relativePath));
+            }
+        }
+    }
+    const criticalCount = findings.filter((f) => f.severity === 'critical').length;
+    const warningCount = findings.filter((f) => f.severity === 'warning').length;
+    const infoCount = findings.filter((f) => f.severity === 'info').length;
+    return {
+        scannedFiles,
+        skippedFiles,
+        totalFindings: findings.length,
+        criticalCount,
+        warningCount,
+        infoCount,
+        findings,
+        duration: Date.now() - startTime,
+        timestamp: new Date().toISOString(),
+    };
+}
+export { allRules } from '../rules/index.js';

package/dist/engine/matcher.d.ts

@@ -0,0 +1,10 @@
+import type { DetectionRule, Finding } from '../rules/types.js';
+export interface MatchResult {
+    match: string;
+    index: number;
+    line: number;
+    column: number;
+    snippet: string;
+}
+export declare function matchRule(content: string, rule: DetectionRule): MatchResult[];
+export declare function createFinding(rule: DetectionRule, matchResult: MatchResult, relativePath: string): Finding;

package/dist/engine/matcher.js

@@ -0,0 +1,47 @@
+import { buildLineIndex, offsetToLineCol, extractSnippet, } from '../utils/line-mapper.js';
+export function matchRule(content, rule) {
+    const results = [];
+    const lineStarts = buildLineIndex(content);
+    const flags = rule.pattern.flags.includes('g')
+        ? rule.pattern.flags
+        : rule.pattern.flags + 'g';
+    const regex = new RegExp(rule.pattern.source, flags);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const matchText = match[0];
+        if (rule.allowPatterns?.some((p) => p.test(matchText))) {
+            continue;
+        }
+        const { line, column } = offsetToLineCol(match.index, lineStarts);
+        const snippet = extractSnippet(content, line, lineStarts);
+        results.push({
+            match: matchText,
+            index: match.index,
+            line,
+            column,
+            snippet,
+        });
+        if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
+    }
+    return results;
+}
+export function createFinding(rule, matchResult, relativePath) {
+    return {
+        ruleId: rule.id,
+        title: rule.title,
+        severity: rule.severity,
+        category: rule.category,
+        file: relativePath,
+        line: matchResult.line,
+        column: matchResult.column,
+        snippet: matchResult.snippet,
+        match: matchResult.match,
+        matchOffset: matchResult.index,
+        message: rule.message,
+        remediation: rule.remediation,
+        cwe: rule.cwe,
+        owasp: rule.owasp,
+    };
+}