@dollhousemcp/mcp-server 1.3.0

package/dist/security/audit/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Security Audit Module - Main exports
+ * Provides automated security scanning for DollhouseMCP
+ */
+export { SecurityAuditor } from './SecurityAuditor.js';
+export * from './types.js';
+export { CodeScanner } from './scanners/CodeScanner.js';
+export { DependencyScanner } from './scanners/DependencyScanner.js';
+export { ConfigurationScanner } from './scanners/ConfigurationScanner.js';
+export { ConsoleReporter } from './reporters/ConsoleReporter.js';
+export { MarkdownReporter } from './reporters/MarkdownReporter.js';
+export { JsonReporter } from './reporters/JsonReporter.js';
+export { SecurityRules } from './rules/SecurityRules.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/security/audit/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/security/audit/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/security/audit/index.js

@@ -0,0 +1,15 @@
+/**
+ * Security Audit Module - Main exports
+ * Provides automated security scanning for DollhouseMCP
+ */
+export { SecurityAuditor } from './SecurityAuditor.js';
+export * from './types.js';
+// Re-export commonly used components
+export { CodeScanner } from './scanners/CodeScanner.js';
+export { DependencyScanner } from './scanners/DependencyScanner.js';
+export { ConfigurationScanner } from './scanners/ConfigurationScanner.js';
+export { ConsoleReporter } from './reporters/ConsoleReporter.js';
+export { MarkdownReporter } from './reporters/MarkdownReporter.js';
+export { JsonReporter } from './reporters/JsonReporter.js';
+export { SecurityRules } from './rules/SecurityRules.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VjdXJpdHkvYXVkaXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3ZELGNBQWMsWUFBWSxDQUFDO0FBRTNCLHFDQUFxQztBQUNyQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDcEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDMUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNlY3VyaXR5IEF1ZGl0IE1vZHVsZSAtIE1haW4gZXhwb3J0c1xuICogUHJvdmlkZXMgYXV0b21hdGVkIHNlY3VyaXR5IHNjYW5uaW5nIGZvciBEb2xsaG91c2VNQ1BcbiAqL1xuXG5leHBvcnQgeyBTZWN1cml0eUF1ZGl0b3IgfSBmcm9tICcuL1NlY3VyaXR5QXVkaXRvci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzLmpzJztcblxuLy8gUmUtZXhwb3J0IGNvbW1vbmx5IHVzZWQgY29tcG9uZW50c1xuZXhwb3J0IHsgQ29kZVNjYW5uZXIgfSBmcm9tICcuL3NjYW5uZXJzL0NvZGVTY2FubmVyLmpzJztcbmV4cG9ydCB7IERlcGVuZGVuY3lTY2FubmVyIH0gZnJvbSAnLi9zY2FubmVycy9EZXBlbmRlbmN5U2Nhbm5lci5qcyc7XG5leHBvcnQgeyBDb25maWd1cmF0aW9uU2Nhbm5lciB9IGZyb20gJy4vc2Nhbm5lcnMvQ29uZmlndXJhdGlvblNjYW5uZXIuanMnO1xuZXhwb3J0IHsgQ29uc29sZVJlcG9ydGVyIH0gZnJvbSAnLi9yZXBvcnRlcnMvQ29uc29sZVJlcG9ydGVyLmpzJztcbmV4cG9ydCB7IE1hcmtkb3duUmVwb3J0ZXIgfSBmcm9tICcuL3JlcG9ydGVycy9NYXJrZG93blJlcG9ydGVyLmpzJztcbmV4cG9ydCB7IEpzb25SZXBvcnRlciB9IGZyb20gJy4vcmVwb3J0ZXJzL0pzb25SZXBvcnRlci5qcyc7XG5leHBvcnQgeyBTZWN1cml0eVJ1bGVzIH0gZnJvbSAnLi9ydWxlcy9TZWN1cml0eVJ1bGVzLmpzJzsiXX0=

package/dist/security/audit/reporters/ConsoleReporter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Console Reporter - Outputs security audit results to console
+ * Provides colorized, human-readable output for CLI usage
+ */
+import type { SecurityReport, ScanResult, SecurityFinding } from '../types.js';
+export declare class ConsoleReporter implements SecurityReport {
+    private result;
+    constructor(result: ScanResult);
+    /**
+     * Generate console output
+     */
+    generate(): string;
+    /**
+     * Get summary section
+     */
+    getSummary(): string;
+    /**
+     * Get findings array
+     */
+    getFindings(): SecurityFinding[];
+    /**
+     * Group findings by severity
+     */
+    private groupFindingsBySeverity;
+    /**
+     * Format a severity section
+     */
+    private formatSeveritySection;
+    /**
+     * Format individual finding
+     */
+    private formatFinding;
+    /**
+     * Format severity label with color
+     */
+    private formatSeverity;
+    /**
+     * Get icon for severity
+     */
+    private getSeverityIcon;
+    /**
+     * Format count with color
+     */
+    private formatCount;
+}
+//# sourceMappingURL=ConsoleReporter.d.ts.map

package/dist/security/audit/reporters/ConsoleReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleReporter.d.ts","sourceRoot":"","sources":["../../../../src/security/audit/reporters/ConsoleReporter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAG9F,qBAAa,eAAgB,YAAW,cAAc;IACpD,OAAO,CAAC,MAAM,CAAa;gBAEf,MAAM,EAAE,UAAU;IAI9B;;OAEG;IACH,QAAQ,IAAI,MAAM;IA+ClB;;OAEG;IACH,UAAU,IAAI,MAAM;IAkBpB;;OAEG;IACH,WAAW,IAAI,eAAe,EAAE;IAIhC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAe7B;;OAEG;IACH,OAAO,CAAC,aAAa;IAqBrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACH,OAAO,CAAC,eAAe;IAevB;;OAEG;IACH,OAAO,CAAC,WAAW;CASpB"}

package/dist/security/audit/reporters/ConsoleReporter.js

@@ -0,0 +1,174 @@
+/**
+ * Console Reporter - Outputs security audit results to console
+ * Provides colorized, human-readable output for CLI usage
+ */
+import chalk from 'chalk';
+export class ConsoleReporter {
+    result;
+    constructor(result) {
+        this.result = result;
+    }
+    /**
+     * Generate console output
+     */
+    generate() {
+        const output = [];
+        // Header
+        output.push('');
+        output.push(chalk.bold.blue('🔒 Security Audit Report'));
+        output.push(chalk.gray('━'.repeat(60)));
+        output.push('');
+        // Summary
+        output.push(this.getSummary());
+        output.push('');
+        // Findings by severity
+        if (this.result.findings.length > 0) {
+            output.push(chalk.bold('📋 Findings:'));
+            output.push('');
+            const findingsBySeverity = this.groupFindingsBySeverity();
+            for (const [severity, findings] of Object.entries(findingsBySeverity)) {
+                if (findings.length > 0) {
+                    output.push(this.formatSeveritySection(severity, findings));
+                }
+            }
+        }
+        else {
+            output.push(chalk.green('✅ No security issues found!'));
+            output.push('');
+        }
+        // Errors
+        if (this.result.errors && this.result.errors.length > 0) {
+            output.push(chalk.bold.red('❌ Errors:'));
+            for (const error of this.result.errors) {
+                output.push(`  • ${error}`);
+            }
+            output.push('');
+        }
+        // Footer
+        output.push(chalk.gray('━'.repeat(60)));
+        output.push(chalk.gray(`Scan completed in ${this.result.duration}ms`));
+        output.push('');
+        return output.join('\n');
+    }
+    /**
+     * Get summary section
+     */
+    getSummary() {
+        const summary = this.result.summary;
+        const output = [];
+        output.push(chalk.bold('📊 Summary:'));
+        output.push(`  Total findings: ${this.formatCount(summary.total)}`);
+        output.push(`  Files scanned: ${this.result.scannedFiles}`);
+        output.push('');
+        output.push('  By severity:');
+        output.push(`    ${this.formatSeverity('critical')}: ${summary.bySeverity.critical}`);
+        output.push(`    ${this.formatSeverity('high')}: ${summary.bySeverity.high}`);
+        output.push(`    ${this.formatSeverity('medium')}: ${summary.bySeverity.medium}`);
+        output.push(`    ${this.formatSeverity('low')}: ${summary.bySeverity.low}`);
+        output.push(`    ${this.formatSeverity('info')}: ${summary.bySeverity.info}`);
+        return output.join('\n');
+    }
+    /**
+     * Get findings array
+     */
+    getFindings() {
+        return this.result.findings;
+    }
+    /**
+     * Group findings by severity
+     */
+    groupFindingsBySeverity() {
+        const grouped = {
+            critical: [],
+            high: [],
+            medium: [],
+            low: [],
+            info: []
+        };
+        for (const finding of this.result.findings) {
+            grouped[finding.severity].push(finding);
+        }
+        return grouped;
+    }
+    /**
+     * Format a severity section
+     */
+    formatSeveritySection(severity, findings) {
+        const output = [];
+        const severityLabel = this.formatSeverity(severity);
+        output.push(`${severityLabel} (${findings.length})`);
+        output.push('');
+        for (const finding of findings) {
+            output.push(this.formatFinding(finding));
+            output.push('');
+        }
+        return output.join('\n');
+    }
+    /**
+     * Format individual finding
+     */
+    formatFinding(finding) {
+        const output = [];
+        const icon = this.getSeverityIcon(finding.severity);
+        output.push(`  ${icon} ${chalk.bold(finding.message)}`);
+        if (finding.file) {
+            const location = finding.line ? `${finding.file}:${finding.line}` : finding.file;
+            output.push(`     📁 ${chalk.cyan(location)}`);
+        }
+        if (finding.code) {
+            output.push(`     📝 ${chalk.gray(finding.code)}`);
+        }
+        output.push(`     💡 ${chalk.yellow(finding.remediation)}`);
+        output.push(`     🏷️  ${chalk.gray(finding.ruleId)} (${finding.confidence} confidence)`);
+        return output.join('\n');
+    }
+    /**
+     * Format severity label with color
+     */
+    formatSeverity(severity) {
+        switch (severity) {
+            case 'critical':
+                return chalk.bgRed.white(' CRITICAL ');
+            case 'high':
+                return chalk.red('HIGH');
+            case 'medium':
+                return chalk.yellow('MEDIUM');
+            case 'low':
+                return chalk.blue('LOW');
+            case 'info':
+                return chalk.gray('INFO');
+        }
+    }
+    /**
+     * Get icon for severity
+     */
+    getSeverityIcon(severity) {
+        switch (severity) {
+            case 'critical':
+                return '🔴';
+            case 'high':
+                return '🟠';
+            case 'medium':
+                return '🟡';
+            case 'low':
+                return '🔵';
+            case 'info':
+                return '⚪';
+        }
+    }
+    /**
+     * Format count with color
+     */
+    formatCount(count) {
+        if (count === 0) {
+            return chalk.green(count.toString());
+        }
+        else if (count < 10) {
+            return chalk.yellow(count.toString());
+        }
+        else {
+            return chalk.red(count.toString());
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConsoleReporter.js","sourceRoot":"","sources":["../../../../src/security/audit/reporters/ConsoleReporter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Console Reporter - Outputs security audit results to console\n * Provides colorized, human-readable output for CLI usage\n */\n\nimport type { SecurityReport, ScanResult, SecurityFinding, SeverityLevel } from '../types.js';\nimport chalk from 'chalk';\n\nexport class ConsoleReporter implements SecurityReport {\n  private result: ScanResult;\n\n  constructor(result: ScanResult) {\n    this.result = result;\n  }\n\n  /**\n   * Generate console output\n   */\n  generate(): string {\n    const output: string[] = [];\n    \n    // Header\n    output.push('');\n    output.push(chalk.bold.blue('🔒 Security Audit Report'));\n    output.push(chalk.gray('━'.repeat(60)));\n    output.push('');\n    \n    // Summary\n    output.push(this.getSummary());\n    output.push('');\n    \n    // Findings by severity\n    if (this.result.findings.length > 0) {\n      output.push(chalk.bold('📋 Findings:'));\n      output.push('');\n      \n      const findingsBySeverity = this.groupFindingsBySeverity();\n      \n      for (const [severity, findings] of Object.entries(findingsBySeverity)) {\n        if (findings.length > 0) {\n          output.push(this.formatSeveritySection(severity as SeverityLevel, findings));\n        }\n      }\n    } else {\n      output.push(chalk.green('✅ No security issues found!'));\n      output.push('');\n    }\n    \n    // Errors\n    if (this.result.errors && this.result.errors.length > 0) {\n      output.push(chalk.bold.red('❌ Errors:'));\n      for (const error of this.result.errors) {\n        output.push(`  • ${error}`);\n      }\n      output.push('');\n    }\n    \n    // Footer\n    output.push(chalk.gray('━'.repeat(60)));\n    output.push(chalk.gray(`Scan completed in ${this.result.duration}ms`));\n    output.push('');\n    \n    return output.join('\\n');\n  }\n\n  /**\n   * Get summary section\n   */\n  getSummary(): string {\n    const summary = this.result.summary;\n    const output: string[] = [];\n    \n    output.push(chalk.bold('📊 Summary:'));\n    output.push(`  Total findings: ${this.formatCount(summary.total)}`);\n    output.push(`  Files scanned: ${this.result.scannedFiles}`);\n    output.push('');\n    output.push('  By severity:');\n    output.push(`    ${this.formatSeverity('critical')}: ${summary.bySeverity.critical}`);\n    output.push(`    ${this.formatSeverity('high')}: ${summary.bySeverity.high}`);\n    output.push(`    ${this.formatSeverity('medium')}: ${summary.bySeverity.medium}`);\n    output.push(`    ${this.formatSeverity('low')}: ${summary.bySeverity.low}`);\n    output.push(`    ${this.formatSeverity('info')}: ${summary.bySeverity.info}`);\n    \n    return output.join('\\n');\n  }\n\n  /**\n   * Get findings array\n   */\n  getFindings(): SecurityFinding[] {\n    return this.result.findings;\n  }\n\n  /**\n   * Group findings by severity\n   */\n  private groupFindingsBySeverity(): Record<SeverityLevel, SecurityFinding[]> {\n    const grouped: Record<SeverityLevel, SecurityFinding[]> = {\n      critical: [],\n      high: [],\n      medium: [],\n      low: [],\n      info: []\n    };\n    \n    for (const finding of this.result.findings) {\n      grouped[finding.severity].push(finding);\n    }\n    \n    return grouped;\n  }\n\n  /**\n   * Format a severity section\n   */\n  private formatSeveritySection(severity: SeverityLevel, findings: SecurityFinding[]): string {\n    const output: string[] = [];\n    const severityLabel = this.formatSeverity(severity);\n    \n    output.push(`${severityLabel} (${findings.length})`);\n    output.push('');\n    \n    for (const finding of findings) {\n      output.push(this.formatFinding(finding));\n      output.push('');\n    }\n    \n    return output.join('\\n');\n  }\n\n  /**\n   * Format individual finding\n   */\n  private formatFinding(finding: SecurityFinding): string {\n    const output: string[] = [];\n    const icon = this.getSeverityIcon(finding.severity);\n    \n    output.push(`  ${icon} ${chalk.bold(finding.message)}`);\n    \n    if (finding.file) {\n      const location = finding.line ? `${finding.file}:${finding.line}` : finding.file;\n      output.push(`     📁 ${chalk.cyan(location)}`);\n    }\n    \n    if (finding.code) {\n      output.push(`     📝 ${chalk.gray(finding.code)}`);\n    }\n    \n    output.push(`     💡 ${chalk.yellow(finding.remediation)}`);\n    output.push(`     🏷️  ${chalk.gray(finding.ruleId)} (${finding.confidence} confidence)`);\n    \n    return output.join('\\n');\n  }\n\n  /**\n   * Format severity label with color\n   */\n  private formatSeverity(severity: SeverityLevel): string {\n    switch (severity) {\n      case 'critical':\n        return chalk.bgRed.white(' CRITICAL ');\n      case 'high':\n        return chalk.red('HIGH');\n      case 'medium':\n        return chalk.yellow('MEDIUM');\n      case 'low':\n        return chalk.blue('LOW');\n      case 'info':\n        return chalk.gray('INFO');\n    }\n  }\n\n  /**\n   * Get icon for severity\n   */\n  private getSeverityIcon(severity: SeverityLevel): string {\n    switch (severity) {\n      case 'critical':\n        return '🔴';\n      case 'high':\n        return '🟠';\n      case 'medium':\n        return '🟡';\n      case 'low':\n        return '🔵';\n      case 'info':\n        return '⚪';\n    }\n  }\n\n  /**\n   * Format count with color\n   */\n  private formatCount(count: number): string {\n    if (count === 0) {\n      return chalk.green(count.toString());\n    } else if (count < 10) {\n      return chalk.yellow(count.toString());\n    } else {\n      return chalk.red(count.toString());\n    }\n  }\n}"]}

package/dist/security/audit/reporters/JsonReporter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * JSON Reporter - Generates JSON reports for programmatic consumption
+ * Placeholder implementation - to be completed
+ */
+import type { SecurityReport, ScanResult, SecurityFinding } from '../types.js';
+export declare class JsonReporter implements SecurityReport {
+    private result;
+    constructor(result: ScanResult);
+    generate(): object;
+    getSummary(): string;
+    getFindings(): SecurityFinding[];
+}
+//# sourceMappingURL=JsonReporter.d.ts.map

package/dist/security/audit/reporters/JsonReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonReporter.d.ts","sourceRoot":"","sources":["../../../../src/security/audit/reporters/JsonReporter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE/E,qBAAa,YAAa,YAAW,cAAc;IACjD,OAAO,CAAC,MAAM,CAAa;gBAEf,MAAM,EAAE,UAAU;IAI9B,QAAQ,IAAI,MAAM;IASlB,UAAU,IAAI,MAAM;IAIpB,WAAW,IAAI,eAAe,EAAE;CAGjC"}

package/dist/security/audit/reporters/JsonReporter.js

@@ -0,0 +1,25 @@
+/**
+ * JSON Reporter - Generates JSON reports for programmatic consumption
+ * Placeholder implementation - to be completed
+ */
+export class JsonReporter {
+    result;
+    constructor(result) {
+        this.result = result;
+    }
+    generate() {
+        // TODO: Implement full JSON report
+        return {
+            timestamp: this.result.timestamp,
+            summary: this.result.summary,
+            findings: this.result.findings
+        };
+    }
+    getSummary() {
+        return JSON.stringify(this.result.summary);
+    }
+    getFindings() {
+        return this.result.findings;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSnNvblJlcG9ydGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlY3VyaXR5L2F1ZGl0L3JlcG9ydGVycy9Kc29uUmVwb3J0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBSUgsTUFBTSxPQUFPLFlBQVk7SUFDZixNQUFNLENBQWE7SUFFM0IsWUFBWSxNQUFrQjtRQUM1QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDO0lBRUQsUUFBUTtRQUNOLG1DQUFtQztRQUNuQyxPQUFPO1lBQ0wsU0FBUyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUztZQUNoQyxPQUFPLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPO1lBQzVCLFFBQVEsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVE7U0FDL0IsQ0FBQztJQUNKLENBQUM7SUFFRCxVQUFVO1FBQ1IsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDN0MsQ0FBQztJQUVELFdBQVc7UUFDVCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDO0lBQzlCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogSlNPTiBSZXBvcnRlciAtIEdlbmVyYXRlcyBKU09OIHJlcG9ydHMgZm9yIHByb2dyYW1tYXRpYyBjb25zdW1wdGlvblxuICogUGxhY2Vob2xkZXIgaW1wbGVtZW50YXRpb24gLSB0byBiZSBjb21wbGV0ZWRcbiAqL1xuXG5pbXBvcnQgdHlwZSB7IFNlY3VyaXR5UmVwb3J0LCBTY2FuUmVzdWx0LCBTZWN1cml0eUZpbmRpbmcgfSBmcm9tICcuLi90eXBlcy5qcyc7XG5cbmV4cG9ydCBjbGFzcyBKc29uUmVwb3J0ZXIgaW1wbGVtZW50cyBTZWN1cml0eVJlcG9ydCB7XG4gIHByaXZhdGUgcmVzdWx0OiBTY2FuUmVzdWx0O1xuXG4gIGNvbnN0cnVjdG9yKHJlc3VsdDogU2NhblJlc3VsdCkge1xuICAgIHRoaXMucmVzdWx0ID0gcmVzdWx0O1xuICB9XG5cbiAgZ2VuZXJhdGUoKTogb2JqZWN0IHtcbiAgICAvLyBUT0RPOiBJbXBsZW1lbnQgZnVsbCBKU09OIHJlcG9ydFxuICAgIHJldHVybiB7XG4gICAgICB0aW1lc3RhbXA6IHRoaXMucmVzdWx0LnRpbWVzdGFtcCxcbiAgICAgIHN1bW1hcnk6IHRoaXMucmVzdWx0LnN1bW1hcnksXG4gICAgICBmaW5kaW5nczogdGhpcy5yZXN1bHQuZmluZGluZ3NcbiAgICB9O1xuICB9XG5cbiAgZ2V0U3VtbWFyeSgpOiBzdHJpbmcge1xuICAgIHJldHVybiBKU09OLnN0cmluZ2lmeSh0aGlzLnJlc3VsdC5zdW1tYXJ5KTtcbiAgfVxuXG4gIGdldEZpbmRpbmdzKCk6IFNlY3VyaXR5RmluZGluZ1tdIHtcbiAgICByZXR1cm4gdGhpcy5yZXN1bHQuZmluZGluZ3M7XG4gIH1cbn0iXX0=

package/dist/security/audit/reporters/MarkdownReporter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Markdown Reporter - Generates markdown reports for GitHub
+ * Placeholder implementation - to be completed
+ */
+import type { SecurityReport, ScanResult, SecurityFinding } from '../types.js';
+export declare class MarkdownReporter implements SecurityReport {
+    private result;
+    constructor(result: ScanResult);
+    generate(): string;
+    getSummary(): string;
+    getFindings(): SecurityFinding[];
+}
+//# sourceMappingURL=MarkdownReporter.d.ts.map

package/dist/security/audit/reporters/MarkdownReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownReporter.d.ts","sourceRoot":"","sources":["../../../../src/security/audit/reporters/MarkdownReporter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE/E,qBAAa,gBAAiB,YAAW,cAAc;IACrD,OAAO,CAAC,MAAM,CAAa;gBAEf,MAAM,EAAE,UAAU;IAI9B,QAAQ,IAAI,MAAM;IAoElB,UAAU,IAAI,MAAM;IAIpB,WAAW,IAAI,eAAe,EAAE;CAGjC"}

package/dist/security/audit/reporters/MarkdownReporter.js

@@ -0,0 +1,79 @@
+/**
+ * Markdown Reporter - Generates markdown reports for GitHub
+ * Placeholder implementation - to be completed
+ */
+export class MarkdownReporter {
+    result;
+    constructor(result) {
+        this.result = result;
+    }
+    generate() {
+        const lines = [];
+        // Header
+        lines.push('# Security Audit Report');
+        lines.push('');
+        lines.push(`Generated: ${new Date().toISOString()}`);
+        lines.push(`Duration: ${this.result.duration}ms`);
+        lines.push('');
+        // Summary
+        lines.push('## Summary');
+        lines.push('');
+        lines.push(`- **Total Findings**: ${this.result.findings.length}`);
+        lines.push(`- **Files Scanned**: ${this.result.scannedFiles}`);
+        lines.push('');
+        // Findings by severity
+        lines.push('### Findings by Severity');
+        lines.push('');
+        lines.push(`- 🔴 **Critical**: ${this.result.summary.bySeverity.critical}`);
+        lines.push(`- 🟠 **High**: ${this.result.summary.bySeverity.high}`);
+        lines.push(`- 🟡 **Medium**: ${this.result.summary.bySeverity.medium}`);
+        lines.push(`- 🟢 **Low**: ${this.result.summary.bySeverity.low}`);
+        lines.push(`- ℹ️ **Info**: ${this.result.summary.bySeverity.info}`);
+        lines.push('');
+        // Detailed findings
+        if (this.result.findings.length > 0) {
+            lines.push('## Detailed Findings');
+            lines.push('');
+            // Group by severity
+            const severityOrder = ['critical', 'high', 'medium', 'low', 'info'];
+            for (const severity of severityOrder) {
+                const findings = this.result.findings.filter(f => f.severity === severity);
+                if (findings.length === 0)
+                    continue;
+                lines.push(`### ${severity.toUpperCase()} (${findings.length})`);
+                lines.push('');
+                for (const finding of findings) {
+                    lines.push(`#### ${finding.ruleId}: ${finding.message}`);
+                    lines.push('');
+                    lines.push(`- **File**: \`${finding.file}\``);
+                    if (finding.line)
+                        lines.push(`- **Line**: ${finding.line}`);
+                    if (finding.column)
+                        lines.push(`- **Column**: ${finding.column}`);
+                    if (finding.code)
+                        lines.push(`- **Code**: \`${finding.code.substring(0, 100)}${finding.code.length > 100 ? '...' : ''}\``);
+                    lines.push(`- **Confidence**: ${finding.confidence || 'medium'}`);
+                    if (finding.remediation)
+                        lines.push(`- **Remediation**: ${finding.remediation}`);
+                    lines.push('');
+                }
+            }
+        }
+        // Recommendations
+        lines.push('## Recommendations');
+        lines.push('');
+        lines.push('1. Address all critical and high severity issues immediately');
+        lines.push('2. Review medium severity issues and plan remediation');
+        lines.push('3. Consider adding suppressions for false positives');
+        lines.push('4. Run security audit regularly (e.g., in CI/CD pipeline)');
+        lines.push('');
+        return lines.join('\n');
+    }
+    getSummary() {
+        return `Found ${this.result.findings.length} security issues`;
+    }
+    getFindings() {
+        return this.result.findings;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MarkdownReporter.js","sourceRoot":"","sources":["../../../../src/security/audit/reporters/MarkdownReporter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Markdown Reporter - Generates markdown reports for GitHub\n * Placeholder implementation - to be completed\n */\n\nimport type { SecurityReport, ScanResult, SecurityFinding } from '../types.js';\n\nexport class MarkdownReporter implements SecurityReport {\n  private result: ScanResult;\n\n  constructor(result: ScanResult) {\n    this.result = result;\n  }\n\n  generate(): string {\n    const lines: string[] = [];\n    \n    // Header\n    lines.push('# Security Audit Report');\n    lines.push('');\n    lines.push(`Generated: ${new Date().toISOString()}`);\n    lines.push(`Duration: ${this.result.duration}ms`);\n    lines.push('');\n    \n    // Summary\n    lines.push('## Summary');\n    lines.push('');\n    lines.push(`- **Total Findings**: ${this.result.findings.length}`);\n    lines.push(`- **Files Scanned**: ${this.result.scannedFiles}`);\n    lines.push('');\n    \n    // Findings by severity\n    lines.push('### Findings by Severity');\n    lines.push('');\n    lines.push(`- 🔴 **Critical**: ${this.result.summary.bySeverity.critical}`);\n    lines.push(`- 🟠 **High**: ${this.result.summary.bySeverity.high}`);\n    lines.push(`- 🟡 **Medium**: ${this.result.summary.bySeverity.medium}`);\n    lines.push(`- 🟢 **Low**: ${this.result.summary.bySeverity.low}`);\n    lines.push(`- ℹ️ **Info**: ${this.result.summary.bySeverity.info}`);\n    lines.push('');\n    \n    // Detailed findings\n    if (this.result.findings.length > 0) {\n      lines.push('## Detailed Findings');\n      lines.push('');\n      \n      // Group by severity\n      const severityOrder: Array<import('../types.js').SeverityLevel> = ['critical', 'high', 'medium', 'low', 'info'];\n      \n      for (const severity of severityOrder) {\n        const findings = this.result.findings.filter(f => f.severity === severity);\n        if (findings.length === 0) continue;\n        \n        lines.push(`### ${severity.toUpperCase()} (${findings.length})`);\n        lines.push('');\n        \n        for (const finding of findings) {\n          lines.push(`#### ${finding.ruleId}: ${finding.message}`);\n          lines.push('');\n          lines.push(`- **File**: \\`${finding.file}\\``);\n          if (finding.line) lines.push(`- **Line**: ${finding.line}`);\n          if (finding.column) lines.push(`- **Column**: ${finding.column}`);\n          if (finding.code) lines.push(`- **Code**: \\`${finding.code.substring(0, 100)}${finding.code.length > 100 ? '...' : ''}\\``);\n          lines.push(`- **Confidence**: ${finding.confidence || 'medium'}`);\n          if (finding.remediation) lines.push(`- **Remediation**: ${finding.remediation}`);\n          lines.push('');\n        }\n      }\n    }\n    \n    // Recommendations\n    lines.push('## Recommendations');\n    lines.push('');\n    lines.push('1. Address all critical and high severity issues immediately');\n    lines.push('2. Review medium severity issues and plan remediation');\n    lines.push('3. Consider adding suppressions for false positives');\n    lines.push('4. Run security audit regularly (e.g., in CI/CD pipeline)');\n    lines.push('');\n    \n    return lines.join('\\n');\n  }\n\n  getSummary(): string {\n    return `Found ${this.result.findings.length} security issues`;\n  }\n\n  getFindings(): SecurityFinding[] {\n    return this.result.findings;\n  }\n}"]}

package/dist/security/audit/rules/SecurityRules.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Security Rules - Defines security patterns and checks
+ * Based on OWASP Top 10, CWE Top 25, and DollhouseMCP-specific security requirements
+ */
+import type { SecurityRule } from '../types.js';
+export declare class SecurityRules {
+    /**
+     * OWASP Top 10 security rules
+     */
+    getOWASPRules(): SecurityRule[];
+    /**
+     * CWE Top 25 security rules
+     */
+    getCWERules(): SecurityRule[];
+    /**
+     * DollhouseMCP-specific security rules
+     */
+    getDollhouseMCPRules(): SecurityRule[];
+}
+//# sourceMappingURL=SecurityRules.d.ts.map

package/dist/security/audit/rules/SecurityRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityRules.d.ts","sourceRoot":"","sources":["../../../../src/security/audit/rules/SecurityRules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,aAAa,CAAC;AAEjE,qBAAa,aAAa;IACxB;;OAEG;IACH,aAAa,IAAI,YAAY,EAAE;IA4E/B;;OAEG;IACH,WAAW,IAAI,YAAY,EAAE;IA6C7B;;OAEG;IACH,oBAAoB,IAAI,YAAY,EAAE;CAmHvC"}