Skip to content

foryourhealth111-pixel/Vibe-Skills / bundled/skills/iso-13485-certification

iso-13485-certification

Verified

Comprehensive toolkit for preparing ISO 13485 certification documentation for medical device Quality Management Systems. Use when users need help with ISO 13485 QMS documentation, including (1) conducting gap analysis of existing documentation, (2) creating Quality Manuals, (3) developing required procedures and work instructions, (4) preparing Medical Device Files, (5) understanding ISO 13485 requirements, or (6) identifying missing documentation for medical device certification. Also use when users mention medical device regulations, QMS certification, FDA QMSR, EU MDR, or need help with quality system documentation.

scripts/gap_analyzer.py

View on GitHub
#!/usr/bin/env python3
"""
ISO 13485 Gap Analysis Tool

This script analyzes documentation provided by the user and identifies gaps
against ISO 13485:2016 requirements.

Usage:
    python gap_analyzer.py --docs-dir <path> [--output <path>]
"""

import os
import sys
import argparse
import json
from pathlib import Path
from typing import Dict, List, Set, Tuple
from datetime import datetime


# ISO 13485:2016 Required Documented Procedures
REQUIRED_PROCEDURES = {
    "4.1.5": {
        "title": "Risk Management",
        "keywords": ["risk", "risk management", "iso 14971", "risk analysis", "risk control"],
        "clause": "4.1.5"
    },
    "4.1.6": {
        "title": "Software Validation",
        "keywords": ["software validation", "computer software", "software application", "validation"],
        "clause": "4.1.6"
    },
    "4.2.4": {
        "title": "Control of Documents",
        "keywords": ["document control", "document approval", "document revision", "obsolete document"],
        "clause": "4.2.4"
    },
    "4.2.5": {
        "title": "Control of Records",
        "keywords": ["record control", "retention", "record storage", "record retrieval"],
        "clause": "4.2.5"
    },
    "5.5.3": {
        "title": "Internal Communication",
        "keywords": ["internal communication", "communication process", "qms communication"],
        "clause": "5.5.3"
    },
    "5.6.1": {
        "title": "Management Review",
        "keywords": ["management review", "review meeting", "management meeting"],
        "clause": "5.6.1"
    },
    "6.2": {
        "title": "Human Resources / Competence",
        "keywords": ["competence", "training", "human resources", "personnel qualification"],
        "clause": "6.2"
    },
    "7.2.3": {
        "title": "Customer Communication",
        "keywords": ["customer communication", "customer feedback", "advisory notice"],
        "clause": "7.2.3"
    },
    "7.3": {
        "title": "Design and Development",
        "keywords": ["design", "development", "design input", "design output", "design verification", "design validation"],
        "clause": "7.3"
    },
    "7.4.1": {
        "title": "Purchasing",
        "keywords": ["purchasing", "supplier", "procurement", "vendor"],
        "clause": "7.4.1"
    },
    "7.4.3": {
        "title": "Verification of Purchased Product",
        "keywords": ["purchased product", "incoming inspection", "verification of purchased"],
        "clause": "7.4.3"
    },
    "7.5.1": {
        "title": "Production and Service Provision",
        "keywords": ["production", "manufacturing", "work instruction", "process control"],
        "clause": "7.5.1"
    },
    "7.5.6": {
        "title": "Process Validation",
        "keywords": ["process validation", "validation protocol", "validation report"],
        "clause": "7.5.6"
    },
    "7.5.8": {
        "title": "Product Identification",
        "keywords": ["product identification", "identification", "labeling", "marking"],
        "clause": "7.5.8"
    },
    "7.5.9": {
        "title": "Traceability",
        "keywords": ["traceability", "lot", "serial number", "batch"],
        "clause": "7.5.9"
    },
    "7.5.11": {
        "title": "Preservation of Product",
        "keywords": ["preservation", "storage", "packaging", "handling"],
        "clause": "7.5.11"
    },
    "7.6": {
        "title": "Control of Monitoring and Measuring Equipment",
        "keywords": ["calibration", "monitoring equipment", "measuring equipment", "measurement"],
        "clause": "7.6"
    },
    "8.2.1": {
        "title": "Feedback",
        "keywords": ["feedback", "post-production", "post-market", "early warning"],
        "clause": "8.2.1"
    },
    "8.2.2": {
        "title": "Complaint Handling",
        "keywords": ["complaint", "customer complaint", "complaint handling", "complaint investigation"],
        "clause": "8.2.2"
    },
    "8.2.3": {
        "title": "Reporting to Regulatory Authorities",
        "keywords": ["regulatory reporting", "adverse event", "mdr report", "reportable event"],
        "clause": "8.2.3"
    },
    "8.2.4": {
        "title": "Internal Audit",
        "keywords": ["internal audit", "audit program", "audit plan", "audit checklist"],
        "clause": "8.2.4"
    },
    "8.2.5": {
        "title": "Monitoring and Measurement of Processes",
        "keywords": ["process monitoring", "process measurement", "process metrics"],
        "clause": "8.2.5"
    },
    "8.2.6": {
        "title": "Monitoring and Measurement of Product",
        "keywords": ["product inspection", "product testing", "acceptance criteria", "release"],
        "clause": "8.2.6"
    },
    "8.3": {
        "title": "Control of Nonconforming Product",
        "keywords": ["nonconforming", "ncr", "nonconformance", "reject"],
        "clause": "8.3"
    },
    "8.5.2": {
        "title": "Corrective Action",
        "keywords": ["corrective action", "capa", "root cause"],
        "clause": "8.5.2"
    },
    "8.5.3": {
        "title": "Preventive Action",
        "keywords": ["preventive action", "capa", "prevention"],
        "clause": "8.5.3"
    }
}

# Additional key documents (not procedures but required)
KEY_DOCUMENTS = {
    "Quality Manual": ["quality manual", "qm-", "quality management system"],
    "Medical Device File": ["medical device file", "mdf", "device master record", "dmr"],
    "Quality Policy": ["quality policy"],
    "Quality Objectives": ["quality objective"],
}


class GapAnalyzer:
    """Analyzes documentation against ISO 13485 requirements."""

    def __init__(self, docs_dir: str):
        """Initialize analyzer with document directory."""
        self.docs_dir = Path(docs_dir)
        self.found_procedures: Dict[str, List[str]] = {}
        self.found_documents: Dict[str, List[str]] = {}

    def analyze(self) -> Dict:
        """Run gap analysis on provided documentation."""
        print(f"Analyzing documents in: {self.docs_dir}")

        if not self.docs_dir.exists():
            print(f"ERROR: Directory not found: {self.docs_dir}")
            return {}

        # Scan all documents
        documents = self._scan_documents()
        print(f"Found {len(documents)} documents to analyze")

        # Search for each required procedure
        for clause_id, proc_info in REQUIRED_PROCEDURES.items():
            self._search_for_procedure(documents, clause_id, proc_info)

        # Search for key documents
        for doc_name, keywords in KEY_DOCUMENTS.items():
            self._search_for_document(documents, doc_name, keywords)

        # Generate gap analysis report
        report = self._generate_report()

        return report

    def _scan_documents(self) -> List[Tuple[Path, str]]:
        """Scan directory for documents and read content."""
        documents = []

        # Supported file extensions
        extensions = ['.txt', '.md', '.doc', '.docx', '.pdf', '.odt']

        for ext in extensions:
            for file_path in self.docs_dir.rglob(f'*{ext}'):
                try:
                    # Read file content (simple text reading)
                    if ext in ['.txt', '.md']:
                        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                            content = f.read().lower()
                            documents.append((file_path, content))
                    else:
                        # For other formats, just note the filename
                        # (Full text extraction would require additional libraries)
                        filename = file_path.name.lower()
                        documents.append((file_path, filename))
                except Exception as e:
                    print(f"Warning: Could not read {file_path}: {e}")

        return documents

    def _search_for_procedure(self, documents: List[Tuple[Path, str]],
                             clause_id: str, proc_info: Dict):
        """Search documents for a specific procedure."""
        title = proc_info['title']
        keywords = proc_info['keywords']

        matches = []
        for file_path, content in documents:
            # Check if any keyword appears in the document
            if any(keyword in content for keyword in keywords):
                matches.append(str(file_path.relative_to(self.docs_dir)))

        if matches:
            self.found_procedures[clause_id] = matches

    def _search_for_document(self, documents: List[Tuple[Path, str]],
                            doc_name: str, keywords: List[str]):
        """Search for key documents."""
        matches = []
        for file_path, content in documents:
            if any(keyword in content for keyword in keywords):
                matches.append(str(file_path.relative_to(self.docs_dir)))

        if matches:
            self.found_documents[doc_name] = matches

    def _generate_report(self) -> Dict:
        """Generate comprehensive gap analysis report."""
        total_procedures = len(REQUIRED_PROCEDURES)
        found_count = len(self.found_procedures)
        missing_count = total_procedures - found_count

        missing_procedures = []
        for clause_id, proc_info in REQUIRED_PROCEDURES.items():
            if clause_id not in self.found_procedures:
                missing_procedures.append({
                    "clause": clause_id,
                    "title": proc_info['title'],
                    "keywords": proc_info['keywords']
                })

        missing_documents = []
        for doc_name, keywords in KEY_DOCUMENTS.items():
            if doc_name not in self.found_documents:
                missing_documents.append({
                    "document": doc_name,
                    "keywords": keywords
                })

        compliance_percentage = (found_count / total_procedures) * 100

        report = {
            "analysis_date": datetime.now().isoformat(),
            "documents_analyzed": str(self.docs_dir),
            "summary": {
                "total_required_procedures": total_procedures,
                "procedures_found": found_count,
                "procedures_missing": missing_count,
                "compliance_percentage": round(compliance_percentage, 1)
            },
            "found_procedures": self.found_procedures,
            "missing_procedures": missing_procedures,
            "found_documents": self.found_documents,
            "missing_documents": missing_documents,
            "recommendations": self._generate_recommendations(missing_procedures, missing_documents)
        }

        return report

    def _generate_recommendations(self, missing_procedures: List[Dict],
                                  missing_documents: List[Dict]) -> List[str]:
        """Generate recommendations based on gaps."""
        recommendations = []

        if not self.found_documents.get("Quality Manual"):
            recommendations.append(
                "CRITICAL: Create a Quality Manual - this is the foundational document of your QMS"
            )

        if not self.found_documents.get("Quality Policy"):
            recommendations.append(
                "HIGH PRIORITY: Develop and document your Quality Policy statement"
            )

        if missing_procedures:
            high_priority_clauses = ["8.2.2", "8.5.2", "8.5.3", "7.4.1", "8.2.4"]
            high_priority_missing = [p for p in missing_procedures
                                    if p['clause'] in high_priority_clauses]

            if high_priority_missing:
                titles = [p['title'] for p in high_priority_missing]
                recommendations.append(
                    f"HIGH PRIORITY: Develop the following critical procedures: {', '.join(titles)}"
                )

        if len(missing_procedures) > 20:
            recommendations.append(
                "Consider engaging a consultant or using templates to accelerate QMS development"
            )

        if len(missing_procedures) < 5:
            recommendations.append(
                "You're close to completion! Focus on finalizing remaining procedures and conducting internal audit"
            )

        return recommendations


def print_report(report: Dict):
    """Print formatted gap analysis report."""
    print("\n" + "="*80)
    print(" ISO 13485:2016 GAP ANALYSIS REPORT")
    print("="*80)
    print(f"\nAnalysis Date: {report['analysis_date']}")
    print(f"Documents Location: {report['documents_analyzed']}\n")

    # Summary
    summary = report['summary']
    print("-" * 80)
    print(" SUMMARY")
    print("-" * 80)
    print(f"Total Required Procedures: {summary['total_required_procedures']}")
    print(f"Procedures Found: {summary['procedures_found']}")
    print(f"Procedures Missing: {summary['procedures_missing']}")
    print(f"Compliance: {summary['compliance_percentage']}%\n")

    # Found Procedures
    if report['found_procedures']:
        print("-" * 80)
        print(" FOUND PROCEDURES")
        print("-" * 80)
        for clause_id, files in sorted(report['found_procedures'].items()):
            proc_info = REQUIRED_PROCEDURES[clause_id]
            print(f"\n[{clause_id}] {proc_info['title']}")
            for file in files:
                print(f"  - {file}")

    # Missing Procedures
    if report['missing_procedures']:
        print("\n" + "-" * 80)
        print(" MISSING PROCEDURES")
        print("-" * 80)
        for proc in report['missing_procedures']:
            print(f"\n[{proc['clause']}] {proc['title']}")
            print(f"  Keywords to include: {', '.join(proc['keywords'][:3])}")

    # Found Documents
    if report['found_documents']:
        print("\n" + "-" * 80)
        print(" FOUND KEY DOCUMENTS")
        print("-" * 80)
        for doc_name, files in report['found_documents'].items():
            print(f"\n{doc_name}:")
            for file in files:
                print(f"  - {file}")

    # Missing Documents
    if report['missing_documents']:
        print("\n" + "-" * 80)
        print(" MISSING KEY DOCUMENTS")
        print("-" * 80)
        for doc in report['missing_documents']:
            print(f"  - {doc['document']}")

    # Recommendations
    if report['recommendations']:
        print("\n" + "-" * 80)
        print(" RECOMMENDATIONS")
        print("-" * 80)
        for i, rec in enumerate(report['recommendations'], 1):
            print(f"{i}. {rec}")

    print("\n" + "="*80)
    print(" END OF REPORT")
    print("="*80 + "\n")


def save_report(report: Dict, output_path: str):
    """Save report to JSON file."""
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(report, f, indent=2)
    print(f"Report saved to: {output_path}")


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description='ISO 13485 Gap Analysis Tool',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        '--docs-dir',
        required=True,
        help='Directory containing documentation to analyze'
    )
    parser.add_argument(
        '--output',
        help='Output file path for JSON report (optional)'
    )

    args = parser.parse_args()

    # Run analysis
    analyzer = GapAnalyzer(args.docs_dir)
    report = analyzer.analyze()

    # Print report
    print_report(report)

    # Save report if output path specified
    if args.output:
        save_report(report, args.output)

    return 0


if __name__ == '__main__':
    sys.exit(main())
rea-changelog-updatemorluto/reaPrepare or rewrite REA release changelogs and GitHub release notes from pinned Git history, with verified contributor thanks and Release Please synchronization.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
academy-guideanthropics/skillsStop and check this skill before finishing any reply to a question about how to use Claude or a Claude product — it recommends matching courses, tutorials, and use cases from Claude Academy (academy.claude.com), Anthropic's learning hub. Trigger on: "how do I", "how can I", "getting started with", "what can Claude do", "teach me", "learn to use"; questions about artifacts, projects, skills, plugins, connectors, MCP; requests about rolling Claude out to a team, class, or organization; and any ask for training materials, onboarding content, or learning resources. Use it when the user is learning how to use a feature or product — not when they are mid-task and just want the task done. This skill composes with other skills: after consulting product documentation to answer how a Claude feature works, also check here for a matching course or tutorial — a docs-grounded answer and an Academy recommendation belong together. Only recommend on a strong match; never invent Academy content.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
claude-apianthropics/skillsReference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration. TRIGGER — read BEFORE opening the target file; don't skip because it "looks like a one-liner" — whenever: the prompt names Claude/Anthropic in any form (Claude, Anthropic, Fable, Opus, Sonnet, Haiku, `anthropic`, `@anthropic-ai`, `claude-*`, `us.anthropic.*`, `[1m]`); the user asks about an LLM (pricing/model choice/limits/caching) — never answer from memory; OR the task is LLM-shaped with provider unstated (agent/MCP/tool-definition/multi-agent/RAG/LLM-judge/computer-use; generate/summarize/extract/classify/rewrite/converse over NL; debugging refusals/cutoffs/streaming/tool-calls/tokens). SKIP only when another provider is being worked on (overrides all triggers): OpenAI/GPT/Gemini/Llama/Mistral/Cohere/Ollama named in the query; OR `grep -rE 'openai|langchain_openai|google.generativeai|genai|mistralai|cohere|ollama'` over the project hits (run this grep FIRST if no provider named — don't Read the file).Stars: 198kUpdated Claude CodeCodexUnverifiedInstall
doc-coauthoringanthropics/skillsGuide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.Stars: 198kUpdated Claude CodeCodexVerifiedInstall