@synsci/cli-darwin-x64 1.1.70 → 1.1.72

package/bin/skills/treatment-plans/scripts/check_completeness.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+Check Treatment Plan Completeness
+Validates that all required sections are present in a treatment plan.
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+from typing import List, Tuple
+
+
+# Required sections for all treatment plans
+REQUIRED_SECTIONS = [
+    r'\\section\*\{.*Patient Information',
+    r'\\section\*\{.*Diagnosis.*Assessment',
+    r'\\section\*\{.*Goals',
+    r'\\section\*\{.*Interventions',
+    r'\\section\*\{.*Timeline.*Schedule',
+    r'\\section\*\{.*Monitoring',
+    r'\\section\*\{.*Outcomes',
+    r'\\section\*\{.*Follow[- ]?up',
+    r'\\section\*\{.*Education',
+    r'\\section\*\{.*Risk.*Safety',
+]
+
+# Section descriptions for user-friendly output
+SECTION_DESCRIPTIONS = {
+    0: 'Patient Information (de-identified)',
+    1: 'Diagnosis and Assessment',
+    2: 'Treatment Goals (SMART format)',
+    3: 'Interventions (pharmacological, non-pharmacological, procedural)',
+    4: 'Timeline and Schedule',
+    5: 'Monitoring Parameters',
+    6: 'Expected Outcomes',
+    7: 'Follow-up Plan',
+    8: 'Patient Education',
+    9: 'Risk Mitigation and Safety',
+}
+
+
+def read_file(filepath: Path) -> str:
+    """Read and return file contents."""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+    except FileNotFoundError:
+        print(f"Error: File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def check_sections(content: str) -> Tuple[List[bool], List[str]]:
+    """
+    Check which required sections are present.
+    Returns tuple of (checklist, missing_sections).
+    """
+    checklist = []
+    missing = []
+
+    for i, pattern in enumerate(REQUIRED_SECTIONS):
+        if re.search(pattern, content, re.IGNORECASE):
+            checklist.append(True)
+        else:
+            checklist.append(False)
+            missing.append(SECTION_DESCRIPTIONS[i])
+
+    return checklist, missing
+
+
+def check_smart_goals(content: str) -> Tuple[bool, List[str]]:
+    """
+    Check if SMART goal criteria are mentioned.
+    Returns (has_smart, missing_criteria).
+    """
+    smart_criteria = {
+        'Specific': r'\bspecific\b',
+        'Measurable': r'\bmeasurable\b',
+        'Achievable': r'\bachievable\b',
+        'Relevant': r'\brelevant\b',
+        'Time-bound': r'\btime[- ]?bound\b',
+    }
+
+    missing = []
+    for criterion, pattern in smart_criteria.items():
+        if not re.search(pattern, content, re.IGNORECASE):
+            missing.append(criterion)
+
+    has_smart = len(missing) == 0
+    return has_smart, missing
+
+
+def check_hipaa_notice(content: str) -> bool:
+    """Check if HIPAA de-identification notice is present."""
+    pattern = r'HIPAA|de-identif|protected health information|PHI'
+    return bool(re.search(pattern, content, re.IGNORECASE))
+
+
+def check_provider_signature(content: str) -> bool:
+    """Check if provider signature section is present."""
+    pattern = r'\\section\*\{.*Signature|Provider Signature|Signature'
+    return bool(re.search(pattern, content, re.IGNORECASE))
+
+
+def check_placeholders_remaining(content: str) -> Tuple[int, List[str]]:
+    """
+    Check for uncustomized placeholders [like this].
+    Returns (count, sample_placeholders).
+    """
+    placeholders = re.findall(r'\[([^\]]+)\]', content)
+
+    # Filter out LaTeX commands and references
+    filtered = []
+    for p in placeholders:
+        # Skip if it's a LaTeX command, number, or citation
+        if not (p.startswith('\\') or p.isdigit() or 'cite' in p.lower() or 'ref' in p.lower()):
+            filtered.append(p)
+
+    count = len(filtered)
+    samples = filtered[:5]  # Return up to 5 examples
+
+    return count, samples
+
+
+def display_results(
+    filepath: Path,
+    checklist: List[bool],
+    missing: List[str],
+    smart_complete: bool,
+    smart_missing: List[str],
+    has_hipaa: bool,
+    has_signature: bool,
+    placeholder_count: int,
+    placeholder_samples: List[str],
+):
+    """Display completeness check results."""
+
+    total_sections = len(REQUIRED_SECTIONS)
+    present_count = sum(checklist)
+    completeness_pct = (present_count / total_sections) * 100
+
+    print("\n" + "=" * 70)
+    print("TREATMENT PLAN COMPLETENESS CHECK")
+    print("=" * 70)
+    print(f"\nFile: {filepath}")
+    print(f"File size: {filepath.stat().st_size:,} bytes")
+
+    # Overall completeness
+    print("\n" + "-" * 70)
+    print("OVERALL COMPLETENESS")
+    print("-" * 70)
+    print(f"Required sections present: {present_count}/{total_sections} ({completeness_pct:.0f}%)")
+
+    if completeness_pct == 100:
+        print("✓ All required sections present")
+    else:
+        print(f"✗ {len(missing)} section(s) missing")
+
+    # Section details
+    print("\n" + "-" * 70)
+    print("SECTION CHECKLIST")
+    print("-" * 70)
+
+    for i, (present, desc) in enumerate(zip(checklist, SECTION_DESCRIPTIONS.values())):
+        status = "✓" if present else "✗"
+        print(f"{status} {desc}")
+
+    # Missing sections
+    if missing:
+        print("\n" + "-" * 70)
+        print("MISSING SECTIONS")
+        print("-" * 70)
+        for section in missing:
+            print(f"  • {section}")
+
+    # SMART goals
+    print("\n" + "-" * 70)
+    print("SMART GOALS CHECK")
+    print("-" * 70)
+
+    if smart_complete:
+        print("✓ All SMART criteria mentioned in document")
+    else:
+        print(f"✗ {len(smart_missing)} SMART criterion/criteria not found:")
+        for criterion in smart_missing:
+            print(f"  • {criterion}")
+        print("\nNote: Goals should be Specific, Measurable, Achievable, Relevant, Time-bound")
+
+    # HIPAA notice
+    print("\n" + "-" * 70)
+    print("PRIVACY AND COMPLIANCE")
+    print("-" * 70)
+
+    if has_hipaa:
+        print("✓ HIPAA/de-identification notice present")
+    else:
+        print("✗ HIPAA de-identification notice not found")
+        print("  Recommendation: Include HIPAA Safe Harbor de-identification guidance")
+
+    if has_signature:
+        print("✓ Provider signature section present")
+    else:
+        print("✗ Provider signature section not found")
+
+    # Placeholders
+    print("\n" + "-" * 70)
+    print("CUSTOMIZATION STATUS")
+    print("-" * 70)
+
+    if placeholder_count == 0:
+        print("✓ No uncustomized placeholders detected")
+    else:
+        print(f"⚠ {placeholder_count} placeholder(s) may need customization")
+        print("\nExamples:")
+        for sample in placeholder_samples:
+            print(f"  • [{sample}]")
+        print("\nRecommendation: Replace all [bracketed placeholders] with patient-specific information")
+
+    # Summary
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+
+    # Calculate overall score
+    score_components = [
+        completeness_pct / 100,  # Section completeness (0-1)
+        1.0 if smart_complete else 0.6,  # SMART goals (full or partial credit)
+        1.0 if has_hipaa else 0.0,  # HIPAA notice (binary)
+        1.0 if has_signature else 0.0,  # Signature (binary)
+        1.0 if placeholder_count == 0 else 0.5,  # Customization (full or partial)
+    ]
+
+    overall_score = (sum(score_components) / len(score_components)) * 100
+
+    print(f"\nOverall completeness score: {overall_score:.0f}%")
+
+    if overall_score >= 90:
+        print("Status: ✓ EXCELLENT - Treatment plan is comprehensive")
+    elif overall_score >= 75:
+        print("Status: ✓ GOOD - Minor improvements needed")
+    elif overall_score >= 60:
+        print("Status: ⚠ FAIR - Several sections need attention")
+    else:
+        print("Status: ✗ INCOMPLETE - Significant work needed")
+
+    print("\n" + "=" * 70)
+
+    # Return exit code based on completeness
+    return 0 if completeness_pct >= 80 else 1
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Check treatment plan completeness',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Check a treatment plan file
+  python check_completeness.py my_treatment_plan.tex
+
+  # Check and exit with error code if incomplete (for CI/CD)
+  python check_completeness.py plan.tex && echo "Complete"
+
+This script checks for:
+  - All required sections (10 core sections)
+  - SMART goal criteria
+  - HIPAA de-identification notice
+  - Provider signature section
+  - Uncustomized placeholders
+
+Exit codes:
+  0 - All required sections present (≥80% complete)
+  1 - Missing required sections (<80% complete)
+  2 - File error or invalid arguments
+        """,
+    )
+
+    parser.add_argument('file', type=Path, help='Treatment plan file to check (.tex format)')
+
+    parser.add_argument('-v', '--verbose', action='store_true', help='Show detailed output')
+
+    args = parser.parse_args()
+
+    # Check file exists and is .tex
+    if not args.file.exists():
+        print(f"Error: File not found: {args.file}", file=sys.stderr)
+        sys.exit(2)
+
+    if args.file.suffix.lower() not in ['.tex', '.txt']:
+        print(f"Warning: Expected .tex file, got {args.file.suffix}", file=sys.stderr)
+
+    # Read file
+    content = read_file(args.file)
+
+    # Perform checks
+    checklist, missing = check_sections(content)
+    smart_complete, smart_missing = check_smart_goals(content)
+    has_hipaa = check_hipaa_notice(content)
+    has_signature = check_provider_signature(content)
+    placeholder_count, placeholder_samples = check_placeholders_remaining(content)
+
+    # Display results
+    exit_code = display_results(
+        args.file,
+        checklist,
+        missing,
+        smart_complete,
+        smart_missing,
+        has_hipaa,
+        has_signature,
+        placeholder_count,
+        placeholder_samples,
+    )
+
+    sys.exit(exit_code)
+
+
+if __name__ == '__main__':
+    main()

package/bin/skills/treatment-plans/scripts/generate_template.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+Generate Treatment Plan Template
+Interactive script to select and generate treatment plan templates.
+"""
+
+import argparse
+import os
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+# Template types and descriptions
+TEMPLATES = {
+    'general_medical': {
+        'name': 'General Medical Treatment Plan',
+        'file': 'general_medical_treatment_plan.tex',
+        'description': 'For primary care and chronic disease management (diabetes, hypertension, etc.)',
+    },
+    'rehabilitation': {
+        'name': 'Rehabilitation Treatment Plan',
+        'file': 'rehabilitation_treatment_plan.tex',
+        'description': 'For physical therapy, occupational therapy, and rehabilitation services',
+    },
+    'mental_health': {
+        'name': 'Mental Health Treatment Plan',
+        'file': 'mental_health_treatment_plan.tex',
+        'description': 'For psychiatric and behavioral health treatment',
+    },
+    'chronic_disease': {
+        'name': 'Chronic Disease Management Plan',
+        'file': 'chronic_disease_management_plan.tex',
+        'description': 'For complex multimorbidity and long-term care coordination',
+    },
+    'perioperative': {
+        'name': 'Perioperative Care Plan',
+        'file': 'perioperative_care_plan.tex',
+        'description': 'For surgical and procedural patient management',
+    },
+    'pain_management': {
+        'name': 'Pain Management Plan',
+        'file': 'pain_management_plan.tex',
+        'description': 'For acute and chronic pain treatment (multimodal approach)',
+    },
+}
+
+
+def get_templates_dir():
+    """Get the path to the templates directory."""
+    # Assume script is in .claude/skills/treatment-plans/scripts/
+    script_dir = Path(__file__).parent
+    templates_dir = script_dir.parent / 'assets'
+    return templates_dir
+
+
+def list_templates():
+    """Display available templates."""
+    print("\n" + "=" * 70)
+    print("AVAILABLE TREATMENT PLAN TEMPLATES")
+    print("=" * 70)
+
+    for i, (key, info) in enumerate(TEMPLATES.items(), 1):
+        print(f"\n{i}. {info['name']}")
+        print(f"   Type: {key}")
+        print(f"   File: {info['file']}")
+        print(f"   Description: {info['description']}")
+
+    print("\n" + "=" * 70)
+
+
+def interactive_selection():
+    """Interactive template selection."""
+    list_templates()
+
+    while True:
+        try:
+            choice = input("\nSelect template number (1-6) or 'q' to quit: ").strip().lower()
+
+            if choice == 'q':
+                print("Exiting...")
+                sys.exit(0)
+
+            choice_num = int(choice)
+
+            if 1 <= choice_num <= len(TEMPLATES):
+                template_key = list(TEMPLATES.keys())[choice_num - 1]
+                return template_key
+            else:
+                print(f"Please enter a number between 1 and {len(TEMPLATES)}.")
+        except ValueError:
+            print("Invalid input. Please enter a number or 'q' to quit.")
+
+
+def get_output_filename(template_key, custom_name=None):
+    """Generate output filename."""
+    if custom_name:
+        # Ensure .tex extension
+        if not custom_name.endswith('.tex'):
+            custom_name += '.tex'
+        return custom_name
+
+    # Default: template_key_YYYYMMDD.tex
+    timestamp = datetime.now().strftime('%Y%m%d')
+    return f"{template_key}_plan_{timestamp}.tex"
+
+
+def copy_template(template_key, output_path):
+    """Copy template to output location."""
+    templates_dir = get_templates_dir()
+    template_file = TEMPLATES[template_key]['file']
+    source_path = templates_dir / template_file
+
+    if not source_path.exists():
+        raise FileNotFoundError(f"Template not found: {source_path}")
+
+    # Create output directory if it doesn't exist
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Copy template
+    shutil.copy2(source_path, output_path)
+
+    return output_path
+
+
+def display_success(output_path, template_key):
+    """Display success message with next steps."""
+    template_info = TEMPLATES[template_key]
+
+    print("\n" + "=" * 70)
+    print("✓ TEMPLATE GENERATED SUCCESSFULLY")
+    print("=" * 70)
+    print(f"\nTemplate: {template_info['name']}")
+    print(f"Output file: {output_path}")
+    print(f"File size: {os.path.getsize(output_path):,} bytes")
+
+    print("\n" + "-" * 70)
+    print("NEXT STEPS:")
+    print("-" * 70)
+
+    print("\n1. CUSTOMIZE THE TEMPLATE:")
+    print("   - Open the .tex file in your LaTeX editor")
+    print("   - Replace all [bracketed placeholders] with patient-specific information")
+    print("   - Remove or modify sections as appropriate for your patient")
+
+    print("\n2. COMPILE TO PDF:")
+    print(f"   $ pdflatex {output_path.name}")
+
+    print("\n3. VALIDATE (optional):")
+    print(f"   $ python check_completeness.py {output_path.name}")
+    print(f"   $ python validate_treatment_plan.py {output_path.name}")
+
+    print("\n4. DE-IDENTIFY BEFORE SHARING:")
+    print("   - Remove all HIPAA identifiers (18 identifiers)")
+    print("   - See regulatory_compliance.md reference for details")
+
+    print("\n" + "=" * 70)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Generate treatment plan template',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Interactive mode (recommended for first-time users)
+  python generate_template.py
+
+  # Direct generation with type specification
+  python generate_template.py --type general_medical --output diabetes_plan.tex
+
+  # Generate with default filename
+  python generate_template.py --type mental_health
+
+  # List available templates
+  python generate_template.py --list
+
+Available template types:
+  general_medical, rehabilitation, mental_health, chronic_disease,
+  perioperative, pain_management
+        """,
+    )
+
+    parser.add_argument('--type', choices=list(TEMPLATES.keys()), help='Template type to generate')
+
+    parser.add_argument('--output', help='Output filename (default: auto-generated with timestamp)')
+
+    parser.add_argument('--list', action='store_true', help='List available templates and exit')
+
+    args = parser.parse_args()
+
+    # List templates and exit
+    if args.list:
+        list_templates()
+        return
+
+    # Determine template type
+    if args.type:
+        template_key = args.type
+        print(f"\nGenerating template: {TEMPLATES[template_key]['name']}")
+    else:
+        # Interactive mode
+        template_key = interactive_selection()
+
+    # Determine output filename
+    if args.output:
+        output_filename = args.output
+    else:
+        output_filename = get_output_filename(template_key)
+
+    # Default output to current directory
+    output_path = Path.cwd() / output_filename
+
+    # Confirm overwrite if file exists
+    if output_path.exists():
+        response = input(f"\nFile {output_filename} already exists. Overwrite? (y/n): ").strip().lower()
+        if response != 'y':
+            print("Cancelled.")
+            return
+
+    # Copy template
+    try:
+        output_path = copy_template(template_key, output_path)
+        display_success(output_path, template_key)
+    except Exception as e:
+        print(f"\n✗ ERROR: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()