mirror of
https://github.com/mukul975/Anthropic-Cybersecurity-Skills.git
synced 2026-09-02 22:50:49 +03:00
Add GDPR compliance assessment skill
Adds comprehensive GDPR compliance assessment skill covering Article 30 records, lawful basis validation, data subject rights, DPIAs, breach notification, international transfers, and technical/organizational measures. Features: - 295-line skill body (under 500-line cap) - 1008-char description with negative triggers (under 1024 limit) - 9 files total, all within skill directory - 3 production scripts: article30_parser.py, article30_validator.py, generate_ropa_report.py - Detailed workflow, templates, and references Negative triggers direct users to: - implementing-gdpr-data-protection-controls for Article 32 technical controls - implementing-gdpr-data-subject-access-request for DSAR automation Legal basis: EU Regulation 2016/679, UK GDPR as amended by Data Protection Act 2018 and Data (Use and Access) Act 2025. Effective date: August 2026. Validation: validate-skill.py PASS, lint-descriptions.py PASS
This commit is contained in:
dakshverma23
@@ -0,0 +1,196 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
GDPR Article 30 Records of Processing Activities (RoPA) Parser.
|
||||
|
||||
Parses Data Processing Agreements (DPAs), privacy policies, and contracts to
|
||||
extract Article 30 mandatory fields and generate a structured RoPA (Register
|
||||
of Processing Activities) in JSON format.
|
||||
|
||||
Article 30 requires controllers to maintain written records containing:
|
||||
- Name and contact details of controller (and DPO if designated)
|
||||
- Purposes of processing
|
||||
- Categories of data subjects and personal data
|
||||
- Categories of recipients
|
||||
- International transfers (destination countries + safeguards)
|
||||
- Retention periods (or criteria)
|
||||
- Security measures description
|
||||
|
||||
Usage:
|
||||
python article30_parser.py --input contracts/processors/ --output ropa.json
|
||||
python article30_parser.py --input privacy_policy.md --output ropa.json --mode single
|
||||
|
||||
This is a helper tool; manual review and completion is required. The parser
|
||||
uses keyword extraction and NLP patterns to identify Article 30 fields but
|
||||
cannot guarantee 100% accuracy.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from datetime import datetime, timezone
|
||||
|
||||
# Keywords for field extraction (naive pattern matching; production would use NLP)
|
||||
KEYWORDS = {
|
||||
"purposes": ["purpose", "why we process", "reason for processing", "use of data"],
|
||||
"data_subjects": ["customer", "employee", "user", "visitor", "subscriber", "data subject"],
|
||||
"personal_data": ["name", "email", "address", "phone", "ip address", "device id", "location", "biometric"],
|
||||
"recipients": ["processor", "vendor", "third party", "recipient", "share with", "disclose to"],
|
||||
"retention": ["retention period", "keep for", "store for", "delete after", "retain until"],
|
||||
"transfers": ["transfer to", "country", "outside EU", "outside EEA", "international transfer"],
|
||||
"security": ["encryption", "access control", "security measure", "pseudonymization", "tls", "mfa"]
|
||||
}
|
||||
|
||||
def extract_text(file_path):
|
||||
"""Extract text from markdown, txt, or JSON files."""
|
||||
ext = Path(file_path).suffix.lower()
|
||||
try:
|
||||
with open(file_path, 'r', encoding='utf-8') as f:
|
||||
if ext == '.json':
|
||||
data = json.load(f)
|
||||
# Flatten JSON to text
|
||||
return json.dumps(data, indent=2)
|
||||
else:
|
||||
return f.read()
|
||||
except Exception as e:
|
||||
print(f"[!] Could not read {file_path}: {e}", file=sys.stderr)
|
||||
return ""
|
||||
|
||||
def extract_fields(text, file_name):
|
||||
"""Extract Article 30 fields using keyword patterns."""
|
||||
text_lower = text.lower()
|
||||
extracted = {
|
||||
"source_file": file_name,
|
||||
"purposes": [],
|
||||
"data_subjects": [],
|
||||
"personal_data_categories": [],
|
||||
"recipients": [],
|
||||
"retention_period": None,
|
||||
"international_transfers": [],
|
||||
"security_measures": []
|
||||
}
|
||||
|
||||
# Extract sentences containing keywords
|
||||
sentences = re.split(r'[.!?\n]', text)
|
||||
|
||||
for sent in sentences:
|
||||
sent_lower = sent.lower().strip()
|
||||
if not sent_lower:
|
||||
continue
|
||||
|
||||
# Purposes
|
||||
if any(kw in sent_lower for kw in KEYWORDS["purposes"]):
|
||||
if len(sent) < 200: # Avoid very long sentences
|
||||
extracted["purposes"].append(sent.strip())
|
||||
|
||||
# Data subjects
|
||||
for subj in KEYWORDS["data_subjects"]:
|
||||
if subj in sent_lower:
|
||||
extracted["data_subjects"].append(subj)
|
||||
|
||||
# Personal data categories
|
||||
for cat in KEYWORDS["personal_data"]:
|
||||
if cat in sent_lower:
|
||||
extracted["personal_data_categories"].append(cat)
|
||||
|
||||
# Recipients
|
||||
if any(kw in sent_lower for kw in KEYWORDS["recipients"]):
|
||||
if len(sent) < 200:
|
||||
extracted["recipients"].append(sent.strip())
|
||||
|
||||
# Retention
|
||||
if any(kw in sent_lower for kw in KEYWORDS["retention"]):
|
||||
if not extracted["retention_period"]:
|
||||
extracted["retention_period"] = sent.strip()
|
||||
|
||||
# International transfers
|
||||
if any(kw in sent_lower for kw in KEYWORDS["transfers"]):
|
||||
extracted["international_transfers"].append(sent.strip())
|
||||
|
||||
# Security measures
|
||||
if any(kw in sent_lower for kw in KEYWORDS["security"]):
|
||||
if len(sent) < 200:
|
||||
extracted["security_measures"].append(sent.strip())
|
||||
|
||||
# Deduplicate lists
|
||||
extracted["data_subjects"] = list(set(extracted["data_subjects"]))
|
||||
extracted["personal_data_categories"] = list(set(extracted["personal_data_categories"]))
|
||||
extracted["purposes"] = list(set(extracted["purposes"]))[:5] # Limit to top 5
|
||||
extracted["recipients"] = list(set(extracted["recipients"]))[:5]
|
||||
extracted["security_measures"] = list(set(extracted["security_measures"]))[:5]
|
||||
|
||||
return extracted
|
||||
|
||||
def parse_directory(input_dir):
|
||||
"""Parse all documents in a directory."""
|
||||
ropa_entries = []
|
||||
|
||||
for root, dirs, files in os.walk(input_dir):
|
||||
for file in files:
|
||||
if file.startswith('.'):
|
||||
continue
|
||||
file_path = os.path.join(root, file)
|
||||
print(f"[*] Parsing: {file_path}", file=sys.stderr)
|
||||
text = extract_text(file_path)
|
||||
if text:
|
||||
entry = extract_fields(text, file)
|
||||
ropa_entries.append(entry)
|
||||
|
||||
return ropa_entries
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Parse documents for GDPR Article 30 fields")
|
||||
parser.add_argument("--input", "-i", required=True, help="Input file or directory")
|
||||
parser.add_argument("--output", "-o", default="ropa.json", help="Output JSON file")
|
||||
parser.add_argument("--mode", choices=["single", "directory"], default="directory",
|
||||
help="Parse single file or directory")
|
||||
args = parser.parse_args()
|
||||
|
||||
print(f"[*] Article 30 RoPA Parser - {datetime.now(timezone.utc).isoformat()}", file=sys.stderr)
|
||||
print(f"[*] Input: {args.input}", file=sys.stderr)
|
||||
print(f"[*] Mode: {args.mode}", file=sys.stderr)
|
||||
|
||||
if args.mode == "single":
|
||||
if not os.path.isfile(args.input):
|
||||
print(f"[!] File not found: {args.input}", file=sys.stderr)
|
||||
return 2
|
||||
text = extract_text(args.input)
|
||||
ropa_entries = [extract_fields(text, os.path.basename(args.input))]
|
||||
else:
|
||||
if not os.path.isdir(args.input):
|
||||
print(f"[!] Directory not found: {args.input}", file=sys.stderr)
|
||||
return 2
|
||||
ropa_entries = parse_directory(args.input)
|
||||
|
||||
# Build output structure
|
||||
output = {
|
||||
"organization": {
|
||||
"name": "[TO BE COMPLETED]",
|
||||
"controller_contact": "[TO BE COMPLETED]",
|
||||
"dpo_contact": "[IF REQUIRED]",
|
||||
"generated_date": datetime.now(timezone.utc).isoformat()
|
||||
},
|
||||
"processing_activities": ropa_entries,
|
||||
"completion_notes": [
|
||||
"This is a DRAFT generated by automated parsing.",
|
||||
"Manual review required for accuracy and completeness.",
|
||||
"Fill in [TO BE COMPLETED] placeholders.",
|
||||
"Verify all extracted fields against source documents.",
|
||||
"Add missing Article 30 mandatory fields.",
|
||||
"Consult legal counsel for final RoPA approval."
|
||||
]
|
||||
}
|
||||
|
||||
with open(args.output, 'w') as f:
|
||||
json.dump(output, f, indent=2)
|
||||
|
||||
print(f"\n[✓] Parsed {len(ropa_entries)} document(s)", file=sys.stderr)
|
||||
print(f"[✓] RoPA draft written to: {args.output}", file=sys.stderr)
|
||||
print(f"[!] Manual review required - this is a DRAFT only", file=sys.stderr)
|
||||
|
||||
return 0
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,186 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
GDPR Article 30 RoPA Validator.
|
||||
|
||||
Validates a Records of Processing Activities (RoPA) JSON file against Article 30
|
||||
mandatory fields and flags incomplete or missing entries.
|
||||
|
||||
Checks:
|
||||
- All mandatory Article 30 fields present
|
||||
- Retention periods specified (or criteria documented)
|
||||
- International transfers have documented safeguards
|
||||
- Special category data properly flagged
|
||||
- Security measures documented
|
||||
|
||||
Usage:
|
||||
python article30_validator.py --ropa ropa.json
|
||||
python article30_validator.py --ropa ropa.json --check-retention --check-transfers --strict
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
|
||||
MANDATORY_FIELDS = [
|
||||
"purposes",
|
||||
"data_subjects",
|
||||
"personal_data_categories",
|
||||
"recipients"
|
||||
]
|
||||
|
||||
SPECIAL_CATEGORY_KEYWORDS = [
|
||||
"health", "medical", "biometric", "genetic", "racial", "ethnic",
|
||||
"political", "religious", "trade union", "sex life", "sexual orientation"
|
||||
]
|
||||
|
||||
def validate_entry(entry, index, args):
|
||||
"""Validate a single processing activity entry."""
|
||||
issues = []
|
||||
entry_id = entry.get("source_file", f"Entry {index}")
|
||||
|
||||
# Check mandatory fields
|
||||
for field in MANDATORY_FIELDS:
|
||||
if field not in entry or not entry[field]:
|
||||
issues.append({
|
||||
"severity": "ERROR",
|
||||
"field": field,
|
||||
"message": f"Missing mandatory field: {field}"
|
||||
})
|
||||
elif isinstance(entry[field], list) and len(entry[field]) == 0:
|
||||
issues.append({
|
||||
"severity": "ERROR",
|
||||
"field": field,
|
||||
"message": f"Empty list for mandatory field: {field}"
|
||||
})
|
||||
|
||||
# Check retention period
|
||||
if args.check_retention:
|
||||
if "retention_period" not in entry or not entry["retention_period"]:
|
||||
issues.append({
|
||||
"severity": "WARNING",
|
||||
"field": "retention_period",
|
||||
"message": "Retention period not specified (Article 30(1)(f))"
|
||||
})
|
||||
elif "[TO BE COMPLETED]" in str(entry.get("retention_period", "")):
|
||||
issues.append({
|
||||
"severity": "WARNING",
|
||||
"field": "retention_period",
|
||||
"message": "Retention period placeholder not completed"
|
||||
})
|
||||
|
||||
# Check international transfers
|
||||
if args.check_transfers:
|
||||
transfers = entry.get("international_transfers", [])
|
||||
if len(transfers) > 0:
|
||||
# Check if safeguards are documented
|
||||
safeguards_mentioned = False
|
||||
for transfer in transfers:
|
||||
transfer_lower = str(transfer).lower()
|
||||
if any(word in transfer_lower for word in ["scc", "standard contractual clause", "adequacy", "bcr", "binding corporate rule"]):
|
||||
safeguards_mentioned = True
|
||||
break
|
||||
|
||||
if not safeguards_mentioned:
|
||||
issues.append({
|
||||
"severity": "ERROR",
|
||||
"field": "international_transfers",
|
||||
"message": "International transfers identified but no safeguards documented (Chapter V)"
|
||||
})
|
||||
|
||||
# Check for special category data without additional legal basis
|
||||
personal_data_str = " ".join(entry.get("personal_data_categories", [])).lower()
|
||||
if any(keyword in personal_data_str for keyword in SPECIAL_CATEGORY_KEYWORDS):
|
||||
if "special_category_legal_basis" not in entry:
|
||||
issues.append({
|
||||
"severity": "WARNING",
|
||||
"field": "special_category_legal_basis",
|
||||
"message": "Possible special category data (Article 9) but no additional legal basis documented"
|
||||
})
|
||||
|
||||
# Check security measures
|
||||
if not entry.get("security_measures"):
|
||||
issues.append({
|
||||
"severity": "WARNING",
|
||||
"field": "security_measures",
|
||||
"message": "No security measures documented (Article 32)"
|
||||
})
|
||||
|
||||
return entry_id, issues
|
||||
|
||||
def generate_report(results, args):
|
||||
"""Generate validation report."""
|
||||
total_errors = sum(1 for _, issues in results for issue in issues if issue["severity"] == "ERROR")
|
||||
total_warnings = sum(1 for _, issues in results for issue in issues if issue["severity"] == "WARNING")
|
||||
|
||||
print(f"\n{'='*70}")
|
||||
print(f"GDPR Article 30 RoPA Validation Report")
|
||||
print(f"Generated: {datetime.now(timezone.utc).isoformat()}")
|
||||
print(f"{'='*70}\n")
|
||||
|
||||
print(f"Total Entries: {len(results)}")
|
||||
print(f"Total Errors: {total_errors}")
|
||||
print(f"Total Warnings: {total_warnings}")
|
||||
print()
|
||||
|
||||
if total_errors == 0 and total_warnings == 0:
|
||||
print("✓ All entries passed validation")
|
||||
return 0
|
||||
|
||||
for entry_id, issues in results:
|
||||
if not issues:
|
||||
continue
|
||||
|
||||
print(f"\n{entry_id}")
|
||||
print(f"{'-'*70}")
|
||||
for issue in issues:
|
||||
icon = "✗" if issue["severity"] == "ERROR" else "⚠"
|
||||
print(f" {icon} [{issue['severity']}] {issue['field']}: {issue['message']}")
|
||||
|
||||
print(f"\n{'='*70}")
|
||||
if total_errors > 0:
|
||||
print(f"VALIDATION FAILED: {total_errors} error(s) found")
|
||||
print("Fix errors before using this RoPA for compliance purposes.")
|
||||
return 1
|
||||
else:
|
||||
print(f"VALIDATION PASSED with {total_warnings} warning(s)")
|
||||
print("Review warnings and complete missing optional fields.")
|
||||
return 0
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Validate GDPR Article 30 RoPA")
|
||||
parser.add_argument("--ropa", required=True, help="Path to RoPA JSON file")
|
||||
parser.add_argument("--check-retention", action="store_true",
|
||||
help="Validate retention periods are specified")
|
||||
parser.add_argument("--check-transfers", action="store_true",
|
||||
help="Validate international transfer safeguards")
|
||||
parser.add_argument("--strict", action="store_true",
|
||||
help="Treat warnings as errors")
|
||||
args = parser.parse_args()
|
||||
|
||||
try:
|
||||
with open(args.ropa, 'r') as f:
|
||||
ropa = json.load(f)
|
||||
except (OSError, json.JSONDecodeError) as e:
|
||||
print(f"ERROR: Could not read RoPA file: {e}", file=sys.stderr)
|
||||
return 2
|
||||
|
||||
processing_activities = ropa.get("processing_activities", [])
|
||||
if not processing_activities:
|
||||
print("ERROR: No processing activities found in RoPA", file=sys.stderr)
|
||||
return 2
|
||||
|
||||
results = []
|
||||
for i, entry in enumerate(processing_activities):
|
||||
entry_id, issues = validate_entry(entry, i, args)
|
||||
if args.strict:
|
||||
# Promote warnings to errors in strict mode
|
||||
for issue in issues:
|
||||
if issue["severity"] == "WARNING":
|
||||
issue["severity"] = "ERROR"
|
||||
results.append((entry_id, issues))
|
||||
|
||||
return generate_report(results, args)
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,197 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
GDPR Article 30 RoPA Report Generator.
|
||||
|
||||
Generates a formatted Article 30 Records of Processing Activities report
|
||||
in Markdown format suitable for supervisory authority submission.
|
||||
|
||||
Usage:
|
||||
python generate_ropa_report.py --input ropa.json --output Article30_Register.md
|
||||
python generate_ropa_report.py --input ropa.json --output report.pdf --format pdf
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
|
||||
def format_list(items):
|
||||
"""Format a list of items as bullet points."""
|
||||
if not items:
|
||||
return "*[None specified]*"
|
||||
if isinstance(items, str):
|
||||
return items
|
||||
return "\n".join(f"- {item}" for item in items)
|
||||
|
||||
def generate_markdown(ropa):
|
||||
"""Generate Markdown report from RoPA JSON."""
|
||||
org = ropa.get("organization", {})
|
||||
activities = ropa.get("processing_activities", [])
|
||||
|
||||
lines = []
|
||||
lines.append("# Article 30 Records of Processing Activities")
|
||||
lines.append("")
|
||||
lines.append(f"**Organization**: {org.get('name', '[Organization Name]')}")
|
||||
lines.append(f"**Controller Contact**: {org.get('controller_contact', '[Contact Details]')}")
|
||||
if org.get('dpo_contact'):
|
||||
lines.append(f"**Data Protection Officer**: {org.get('dpo_contact')}")
|
||||
lines.append(f"**Generated**: {org.get('generated_date', datetime.now(timezone.utc).isoformat())}")
|
||||
lines.append(f"**Total Processing Activities**: {len(activities)}")
|
||||
lines.append("")
|
||||
lines.append("---")
|
||||
lines.append("")
|
||||
|
||||
for idx, activity in enumerate(activities, 1):
|
||||
lines.append(f"## Processing Activity {idx}: {activity.get('source_file', 'Unnamed Activity')}")
|
||||
lines.append("")
|
||||
|
||||
# Purposes
|
||||
lines.append("### Purposes of Processing")
|
||||
lines.append(format_list(activity.get('purposes', [])))
|
||||
lines.append("")
|
||||
|
||||
# Data Subjects
|
||||
lines.append("### Categories of Data Subjects")
|
||||
lines.append(format_list(activity.get('data_subjects', [])))
|
||||
lines.append("")
|
||||
|
||||
# Personal Data
|
||||
lines.append("### Categories of Personal Data")
|
||||
lines.append(format_list(activity.get('personal_data_categories', [])))
|
||||
lines.append("")
|
||||
|
||||
# Recipients
|
||||
lines.append("### Categories of Recipients")
|
||||
lines.append(format_list(activity.get('recipients', [])))
|
||||
lines.append("")
|
||||
|
||||
# Retention
|
||||
lines.append("### Retention Period")
|
||||
retention = activity.get('retention_period', '*[Not specified]*')
|
||||
lines.append(f"{retention}")
|
||||
lines.append("")
|
||||
|
||||
# International Transfers
|
||||
lines.append("### International Transfers")
|
||||
transfers = activity.get('international_transfers', [])
|
||||
if transfers:
|
||||
lines.append(format_list(transfers))
|
||||
else:
|
||||
lines.append("*No international transfers*")
|
||||
lines.append("")
|
||||
|
||||
# Security Measures
|
||||
lines.append("### Technical and Organizational Security Measures")
|
||||
lines.append(format_list(activity.get('security_measures', [])))
|
||||
lines.append("")
|
||||
|
||||
lines.append("---")
|
||||
lines.append("")
|
||||
|
||||
# Completion Notes
|
||||
if ropa.get('completion_notes'):
|
||||
lines.append("## Completion Notes")
|
||||
lines.append("")
|
||||
for note in ropa['completion_notes']:
|
||||
lines.append(f"- {note}")
|
||||
lines.append("")
|
||||
|
||||
# Footer
|
||||
lines.append("---")
|
||||
lines.append("*This document fulfills the requirements of GDPR Article 30 (Records of Processing Activities).*")
|
||||
lines.append("*Controllers must maintain this register and make it available to supervisory authorities upon request.*")
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
def generate_html(markdown_content):
|
||||
"""Convert Markdown to basic HTML."""
|
||||
html_header = """<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>Article 30 RoPA</title>
|
||||
<style>
|
||||
body { font-family: Arial, sans-serif; max-width: 900px; margin: 40px auto; padding: 0 20px; }
|
||||
h1 { color: #1a5490; border-bottom: 3px solid #1a5490; }
|
||||
h2 { color: #2563eb; margin-top: 30px; }
|
||||
h3 { color: #4b5563; margin-top: 20px; }
|
||||
hr { margin: 30px 0; border: none; border-top: 1px solid #ddd; }
|
||||
ul { line-height: 1.6; }
|
||||
em { color: #6b7280; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
"""
|
||||
html_footer = """
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
|
||||
# Simple Markdown to HTML conversion
|
||||
html_body = markdown_content
|
||||
html_body = html_body.replace("# ", "<h1>").replace("\n\n", "</h1>\n\n")
|
||||
html_body = html_body.replace("## ", "<h2>").replace("\n\n", "</h2>\n\n")
|
||||
html_body = html_body.replace("### ", "<h3>").replace("\n\n", "</h3>\n\n")
|
||||
html_body = html_body.replace("**", "<strong>").replace("**", "</strong>")
|
||||
html_body = html_body.replace("*[", "<em>[").replace("]*", "]</em>")
|
||||
html_body = html_body.replace("---\n", "<hr>\n")
|
||||
html_body = html_body.replace("- ", "<li>").replace("\n", "</li>\n")
|
||||
|
||||
return html_header + html_body + html_footer
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Generate Article 30 RoPA Report")
|
||||
parser.add_argument("--input", "-i", required=True, help="Input RoPA JSON file")
|
||||
parser.add_argument("--output", "-o", required=True, help="Output file path")
|
||||
parser.add_argument("--format", choices=["markdown", "html", "pdf"], default="markdown",
|
||||
help="Output format (default: markdown)")
|
||||
args = parser.parse_args()
|
||||
|
||||
try:
|
||||
with open(args.input, 'r') as f:
|
||||
ropa = json.load(f)
|
||||
except (OSError, json.JSONDecodeError) as e:
|
||||
print(f"ERROR: Could not read RoPA file: {e}", file=sys.stderr)
|
||||
return 2
|
||||
|
||||
markdown_content = generate_markdown(ropa)
|
||||
|
||||
if args.format == "markdown":
|
||||
with open(args.output, 'w') as f:
|
||||
f.write(markdown_content)
|
||||
print(f"[✓] Markdown report written to: {args.output}", file=sys.stderr)
|
||||
|
||||
elif args.format == "html":
|
||||
html_content = generate_html(markdown_content)
|
||||
with open(args.output, 'w') as f:
|
||||
f.write(html_content)
|
||||
print(f"[✓] HTML report written to: {args.output}", file=sys.stderr)
|
||||
|
||||
elif args.format == "pdf":
|
||||
try:
|
||||
# Try to use markdown2pdf if available
|
||||
import subprocess
|
||||
md_temp = args.output.replace('.pdf', '.md')
|
||||
with open(md_temp, 'w') as f:
|
||||
f.write(markdown_content)
|
||||
|
||||
# Try pandoc first, fall back to instructions
|
||||
result = subprocess.run(['pandoc', md_temp, '-o', args.output],
|
||||
capture_output=True)
|
||||
if result.returncode == 0:
|
||||
print(f"[✓] PDF report written to: {args.output}", file=sys.stderr)
|
||||
import os
|
||||
os.remove(md_temp)
|
||||
else:
|
||||
print(f"[!] pandoc not found. Markdown saved to: {md_temp}", file=sys.stderr)
|
||||
print(f"[!] Install pandoc to generate PDF: apt install pandoc", file=sys.stderr)
|
||||
except Exception as e:
|
||||
print(f"[!] PDF generation requires pandoc: {e}", file=sys.stderr)
|
||||
print(f"[!] Generating Markdown instead: {args.output.replace('.pdf', '.md')}", file=sys.stderr)
|
||||
with open(args.output.replace('.pdf', '.md'), 'w') as f:
|
||||
f.write(markdown_content)
|
||||
|
||||
return 0
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user