kramscan 0.1.0 → 0.2.0

package/dist/agent/skills/generate-report.js

@@ -0,0 +1,436 @@
+"use strict";
+/**
+ * Generate Report Skill
+ * Creates professional security reports in multiple formats (DOCX, TXT, JSON)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateReportSkill = void 0;
+const logger_1 = require("../../utils/logger");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Dynamic imports for report generation libraries
+let docx;
+try {
+    docx = require("docx");
+}
+catch {
+    // docx not available
+}
+class GenerateReportSkill {
+    id = "generate_report";
+    name = "Generate Report";
+    description = "Creates a professional security report in DOCX, TXT, or JSON format based on scan results.";
+    tags = ["reporting", "documentation", "export"];
+    requiresConfirmation = false;
+    riskLevel = "low";
+    estimatedDuration = 10; // seconds
+    toolDefinition = {
+        name: "generate_report",
+        description: "Generate a professional security report from scan results in various formats",
+        parameters: [
+            {
+                name: "useLastScan",
+                type: "boolean",
+                description: "Use results from the most recent scan. If true, scanResults parameter is optional.",
+                required: false,
+                default: true,
+            },
+            {
+                name: "scanResults",
+                type: "object",
+                description: "Scan results to include in report (if not using last scan)",
+                required: false,
+            },
+            {
+                name: "format",
+                type: "string",
+                description: "Report format: 'docx' (Word), 'txt' (text), or 'json'",
+                required: false,
+                default: "docx",
+                enum: ["docx", "txt", "json"],
+            },
+            {
+                name: "outputPath",
+                type: "string",
+                description: "Custom output path for the report. If not provided, saves to ~/.kramscan/reports/",
+                required: false,
+            },
+            {
+                name: "includeAnalysis",
+                type: "boolean",
+                description: "Include AI analysis in the report if available",
+                required: false,
+                default: true,
+            },
+        ],
+    };
+    validateParameters(params) {
+        const errors = [];
+        // Validate format
+        if (params.format) {
+            const validFormats = ["docx", "txt", "json"];
+            if (!validFormats.includes(params.format)) {
+                errors.push(`format must be one of: ${validFormats.join(", ")}`);
+            }
+        }
+        // Check scan data availability
+        if (params.useLastScan === false && !params.scanResults) {
+            errors.push("scanResults is required when useLastScan is false");
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    async execute(params, context) {
+        const useLastScan = params.useLastScan ?? true;
+        const format = params.format ?? "docx";
+        const customPath = params.outputPath;
+        const includeAnalysis = params.includeAnalysis ?? true;
+        let scanData;
+        // Get scan data
+        if (useLastScan) {
+            const lastResults = context.lastScanResults;
+            if (!lastResults) {
+                return {
+                    skillId: this.id,
+                    findings: [],
+                    metadata: {
+                        error: "No previous scan results found. Please run a scan first.",
+                    },
+                };
+            }
+            scanData = lastResults;
+        }
+        else {
+            scanData = params.scanResults;
+        }
+        logger_1.logger.info(`Generating ${format.toUpperCase()} report`);
+        try {
+            // Determine output path
+            let outputPath;
+            if (customPath) {
+                outputPath = customPath;
+            }
+            else {
+                const reportsDir = path.join(os.homedir(), ".kramscan", "reports");
+                await fs.mkdir(reportsDir, { recursive: true });
+                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+                const targetName = scanData.target
+                    ? new URL(scanData.target).hostname
+                    : "scan";
+                outputPath = path.join(reportsDir, `${targetName}-security-report-${timestamp}.${format}`);
+            }
+            // Generate report based on format
+            switch (format.toLowerCase()) {
+                case "docx":
+                    await this.generateDocxReport(scanData, outputPath, includeAnalysis);
+                    break;
+                case "txt":
+                    await this.generateTxtReport(scanData, outputPath, includeAnalysis);
+                    break;
+                case "json":
+                    await this.generateJsonReport(scanData, outputPath);
+                    break;
+                default:
+                    throw new Error(`Unsupported format: ${format}`);
+            }
+            logger_1.logger.success(`Report saved to: ${outputPath}`);
+            return {
+                skillId: this.id,
+                findings: [],
+                metadata: {
+                    outputPath,
+                    format,
+                    target: scanData.target,
+                    totalFindings: scanData.findings?.length || 0,
+                    timestamp: new Date().toISOString(),
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger_1.logger.error(`Report generation failed: ${errorMessage}`);
+            return {
+                skillId: this.id,
+                findings: [],
+                metadata: {
+                    error: errorMessage,
+                    target: scanData.target,
+                },
+            };
+        }
+    }
+    async generateDocxReport(scanData, outputPath, includeAnalysis) {
+        if (!docx) {
+            throw new Error("DOCX generation requires the 'docx' package. Please install it: npm install docx");
+        }
+        const { Document, Paragraph, TextRun, HeadingLevel, Table, TableCell, TableRow, WidthType, BorderStyle, } = docx;
+        const findings = scanData.findings || [];
+        const analysisFinding = includeAnalysis
+            ? findings.find((f) => f.skillId === "analyze_findings")
+            : null;
+        const vulnerabilities = findings.filter((f) => f.skillId !== "analyze_findings");
+        // Create document sections
+        const children = [
+            new Paragraph({
+                text: "Security Assessment Report",
+                heading: HeadingLevel.TITLE,
+            }),
+            new Paragraph({
+                text: `Target: ${scanData.target || "N/A"}`,
+                spacing: { after: 200 },
+            }),
+            new Paragraph({
+                text: `Generated: ${new Date().toLocaleString()}`,
+                spacing: { after: 400 },
+            }),
+        ];
+        // Executive Summary
+        children.push(new Paragraph({
+            text: "Executive Summary",
+            heading: HeadingLevel.HEADING_1,
+        }));
+        const severityCount = this.getSeverityCount(vulnerabilities);
+        children.push(new Paragraph({
+            children: [
+                new TextRun({
+                    text: `Total Vulnerabilities Found: ${vulnerabilities.length}`,
+                    bold: true,
+                }),
+            ],
+            spacing: { after: 200 },
+        }));
+        if (severityCount.critical > 0) {
+            children.push(new Paragraph({
+                text: `Critical: ${severityCount.critical}`,
+                spacing: { after: 100 },
+            }));
+        }
+        if (severityCount.high > 0) {
+            children.push(new Paragraph({
+                text: `High: ${severityCount.high}`,
+                spacing: { after: 100 },
+            }));
+        }
+        if (severityCount.medium > 0) {
+            children.push(new Paragraph({
+                text: `Medium: ${severityCount.medium}`,
+                spacing: { after: 100 },
+            }));
+        }
+        if (severityCount.low > 0) {
+            children.push(new Paragraph({
+                text: `Low: ${severityCount.low}`,
+                spacing: { after: 100 },
+            }));
+        }
+        // AI Analysis section
+        if (analysisFinding) {
+            children.push(new Paragraph({
+                text: "AI Analysis",
+                heading: HeadingLevel.HEADING_1,
+                spacing: { before: 400 },
+            }));
+            children.push(new Paragraph({
+                text: analysisFinding.description,
+                spacing: { after: 400 },
+            }));
+        }
+        // Detailed Findings
+        if (vulnerabilities.length > 0) {
+            children.push(new Paragraph({
+                text: "Detailed Findings",
+                heading: HeadingLevel.HEADING_1,
+                spacing: { before: 400 },
+            }));
+            vulnerabilities.forEach((vuln, index) => {
+                children.push(new Paragraph({
+                    text: `${index + 1}. ${vuln.title}`,
+                    heading: HeadingLevel.HEADING_2,
+                    spacing: { before: 300 },
+                }));
+                children.push(new Paragraph({
+                    children: [
+                        new TextRun({ text: "Severity: ", bold: true }),
+                        new TextRun({
+                            text: vuln.severity.toUpperCase(),
+                            color: this.getSeverityColor(vuln.severity),
+                        }),
+                    ],
+                    spacing: { after: 100 },
+                }));
+                children.push(new Paragraph({
+                    text: vuln.description,
+                    spacing: { after: 200 },
+                }));
+                if (vuln.evidence) {
+                    children.push(new Paragraph({
+                        children: [new TextRun({ text: "Evidence:", bold: true })],
+                        spacing: { before: 100 },
+                    }));
+                    children.push(new Paragraph({
+                        text: vuln.evidence,
+                        spacing: { after: 200 },
+                    }));
+                }
+                if (vuln.recommendation) {
+                    children.push(new Paragraph({
+                        children: [
+                            new TextRun({ text: "Recommendation:", bold: true }),
+                        ],
+                        spacing: { before: 100 },
+                    }));
+                    children.push(new Paragraph({
+                        text: vuln.recommendation,
+                        spacing: { after: 200 },
+                    }));
+                }
+                if (vuln.references && vuln.references.length > 0) {
+                    children.push(new Paragraph({
+                        children: [new TextRun({ text: "References:", bold: true })],
+                        spacing: { before: 100 },
+                    }));
+                    vuln.references.forEach((ref) => {
+                        children.push(new Paragraph({
+                            text: ref,
+                            spacing: { after: 100 },
+                        }));
+                    });
+                }
+            });
+        }
+        const doc = new Document({
+            sections: [
+                {
+                    properties: {},
+                    children,
+                },
+            ],
+        });
+        const buffer = await docx.Packer.toBuffer(doc);
+        await fs.writeFile(outputPath, buffer);
+    }
+    async generateTxtReport(scanData, outputPath, includeAnalysis) {
+        const findings = scanData.findings || [];
+        const analysisFinding = includeAnalysis
+            ? findings.find((f) => f.skillId === "analyze_findings")
+            : null;
+        const vulnerabilities = findings.filter((f) => f.skillId !== "analyze_findings");
+        let content = "SECURITY ASSESSMENT REPORT\n";
+        content += "=".repeat(50) + "\n\n";
+        content += `Target: ${scanData.target || "N/A"}\n`;
+        content += `Generated: ${new Date().toLocaleString()}\n\n`;
+        content += "EXECUTIVE SUMMARY\n";
+        content += "-".repeat(50) + "\n";
+        content += `Total Vulnerabilities Found: ${vulnerabilities.length}\n`;
+        const severityCount = this.getSeverityCount(vulnerabilities);
+        if (severityCount.critical > 0)
+            content += `Critical: ${severityCount.critical}\n`;
+        if (severityCount.high > 0)
+            content += `High: ${severityCount.high}\n`;
+        if (severityCount.medium > 0)
+            content += `Medium: ${severityCount.medium}\n`;
+        if (severityCount.low > 0)
+            content += `Low: ${severityCount.low}\n`;
+        content += "\n";
+        if (analysisFinding) {
+            content += "AI ANALYSIS\n";
+            content += "-".repeat(50) + "\n";
+            content += analysisFinding.description + "\n\n";
+        }
+        if (vulnerabilities.length > 0) {
+            content += "DETAILED FINDINGS\n";
+            content += "-".repeat(50) + "\n\n";
+            vulnerabilities.forEach((vuln, index) => {
+                content += `${index + 1}. ${vuln.title}\n`;
+                content += `   Severity: ${vuln.severity.toUpperCase()}\n`;
+                content += `   Description: ${vuln.description}\n`;
+                if (vuln.evidence) {
+                    content += `   Evidence: ${vuln.evidence}\n`;
+                }
+                if (vuln.recommendation) {
+                    content += `   Recommendation: ${vuln.recommendation}\n`;
+                }
+                if (vuln.references && vuln.references.length > 0) {
+                    content += `   References:\n`;
+                    vuln.references.forEach((ref) => {
+                        content += `     - ${ref}\n`;
+                    });
+                }
+                content += "\n";
+            });
+        }
+        await fs.writeFile(outputPath, content);
+    }
+    async generateJsonReport(scanData, outputPath) {
+        const report = {
+            generatedAt: new Date().toISOString(),
+            target: scanData.target,
+            scanTimestamp: scanData.timestamp,
+            metadata: scanData.metadata,
+            findings: scanData.findings,
+        };
+        await fs.writeFile(outputPath, JSON.stringify(report, null, 2));
+    }
+    getSeverityCount(findings) {
+        return {
+            critical: findings.filter((f) => f.severity === "critical").length,
+            high: findings.filter((f) => f.severity === "high").length,
+            medium: findings.filter((f) => f.severity === "medium").length,
+            low: findings.filter((f) => f.severity === "low").length,
+        };
+    }
+    getSeverityColor(severity) {
+        switch (severity) {
+            case "critical":
+                return "FF0000";
+            case "high":
+                return "FF4500";
+            case "medium":
+                return "FFA500";
+            case "low":
+                return "FFD700";
+            default:
+                return "808080";
+        }
+    }
+    async run() {
+        throw new Error("Use execute() method with AgentContext for generate report skill");
+    }
+}
+exports.GenerateReportSkill = GenerateReportSkill;

package/dist/agent/skills/health-check.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Health Check Skill
+ * Verifies system configuration, dependencies, and environment setup
+ */
+import { AgentSkill, ToolDefinition, AgentContext, SkillResult } from "../types";
+export declare class HealthCheckSkill implements AgentSkill {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    requiresConfirmation: boolean;
+    riskLevel: "low";
+    estimatedDuration: number;
+    toolDefinition: ToolDefinition;
+    validateParameters(params: Record<string, unknown>): {
+        valid: boolean;
+        errors: string[];
+    };
+    execute(params: Record<string, unknown>, context: AgentContext): Promise<SkillResult>;
+    private checkNodeVersion;
+    private checkConfiguration;
+    private checkAIProvider;
+    private checkDependencies;
+    private checkDirectories;
+    private createFinding;
+    private getRecommendation;
+    run(): Promise<SkillResult>;
+}