Added paragraph and sentence length checks

app.py

@@ -662,7 +662,7 @@ class FAADocumentChecker(DocumentChecker):
         'DISTRIBUTION', 'EXCEPTION', 'EXPLANATION', 'FIGURE', 'GENERAL', 'GROUPS', 
         'INFORMATION', 'INSERT', 'INTRODUCTION', 'MATERIAL', 'NOTE', 'PARTS', 'PAST', 
         'POLICY', 'PRACTICE', 'PROCEDURES', 'PURPOSE', 'RELEVANT', 'RELATED', 
-        'REQUIREMENTS', 'SCOPE', 'SECTION', 'SUMMARY', 'TABLE', 'WARNING'
+        'REQUIREMENTS', 'REPORT', 'SCOPE', 'SECTION', 'SUMMARY', 'TABLE', 'WARNING'
     }
     
     PREDEFINED_ACRONYMS = {
@@ -1457,6 +1457,7 @@ class FAADocumentChecker(DocumentChecker):
         
         # Patterns to ignore (aviation references)
         ignore_patterns = [
+            r'\bAC\s*\d+(?:[-.]\d+)*[A-Z]*\b', # AC reference pattern
             r'\bAD \d{4}-\d{2}-\d{2}\b',      # Airworthiness Directive references
             r'\bSWPM \d{2}-\d{2}-\d{2}\b',    # Standard Wiring Practices Manual references
             r'\bAMM \d{2}-\d{2}-\d{2}\b',     # Aircraft Maintenance Manual references
@@ -1667,20 +1668,21 @@ class FAADocumentChecker(DocumentChecker):
         check_sequence = [
             ('heading_title_check', lambda: self.heading_title_check(doc, doc_type)),
             ('heading_title_period_check', lambda: self.heading_title_period_check(doc, doc_type)),
+            ('terminology_check', lambda: self.check_terminology(doc)),
             ('acronym_check', lambda: self.acronym_check(doc)),
             ('acronym_usage_check', lambda: self.acronym_usage_check(doc)),
-            ('terminology_check', lambda: self.check_terminology(doc)),
             ('section_symbol_usage_check', lambda: self.check_section_symbol_usage(doc)),
+            ('date_formats_check', lambda: self.check_date_formats(doc)),
+            ('placeholders_check', lambda: self.check_placeholders(doc)),
+            ('document_title_check', lambda: self.document_title_check(doc_path, doc_type) if not skip_title_check else DocumentCheckResult(success=True, issues=[])),
             ('caption_check_table', lambda: self.caption_check(doc, doc_type, 'Table')),
             ('caption_check_figure', lambda: self.caption_check(doc, doc_type, 'Figure')),
             ('table_figure_reference_check', lambda: self.table_figure_reference_check(doc, doc_type)),
-            ('document_title_check', lambda: self.document_title_check(doc_path, doc_type) if not skip_title_check else DocumentCheckResult(success=True, issues=[])),
+            ('parentheses_check', lambda: self.check_parentheses(doc)),
             ('double_period_check', lambda: self.double_period_check(doc)),
             ('spacing_check', lambda: self.spacing_check(doc)),
-            ('abbreviation_usage_check', lambda: self.check_abbreviation_usage(doc)),
-            ('date_formats_check', lambda: self.check_date_formats(doc)),
-            ('placeholders_check', lambda: self.check_placeholders(doc)),
-            ('parentheses_check', lambda: self.check_parentheses(doc))
+            ('paragraph_length_check', lambda: self.check_paragraph_length(doc)),
+            ('sentence_length_check', lambda: self.check_sentence_length(doc)),
         ]
 
         # Run each check and store results
@@ -1871,6 +1873,369 @@ class FAADocumentChecker(DocumentChecker):
         
         return formatted_issues
 
+    @profile_performance
+    def check_abbreviation_usage(self, doc: List[str]) -> DocumentCheckResult:
+        """Check for abbreviation consistency after first definition."""
+        if not self.validate_input(doc):
+            return DocumentCheckResult(success=False, issues=[{'error': 'Invalid document input'}])
+
+        # Track abbreviations and their usage
+        abbreviations = {}  # Store defined abbreviations
+        inconsistent_uses = []  # Track full term usage after definition
+
+        def process_sentence(sentence: str) -> None:
+            """Process a single sentence for abbreviation usage."""
+            for acronym, data in abbreviations.items():
+                full_term = data["full_term"]
+                if full_term not in sentence:
+                    continue
+                    
+                # Skip if this is the definition sentence
+                if sentence.strip() == data["first_occurrence"]:
+                    continue
+                    
+                # Track inconsistent usage
+                if not data["defined"]:
+                    inconsistent_uses.append({
+                        'issue_type': 'full_term_after_acronym',
+                        'full_term': full_term,
+                        'acronym': acronym,
+                        'sentence': sentence.strip(),
+                        'definition_context': data["first_occurrence"]
+                    })
+                data["defined"] = False  # Mark as used
+
+        # Process each paragraph
+        for paragraph in doc:
+            sentences = re.split(r'(?<=[.!?])\s+', paragraph)
+            for sentence in sentences:
+                process_sentence(sentence.strip())
+
+        success = len(inconsistent_uses) == 0
+        return DocumentCheckResult(success=success, issues=inconsistent_uses)
+
+    @profile_performance
+    def check_date_formats(self, doc: List[str]) -> DocumentCheckResult:
+        """Check for inconsistent date formats while ignoring aviation reference numbers."""
+        if not self.validate_input(doc):
+            return DocumentCheckResult(success=False, issues=[{'error': 'Invalid document input'}])
+        
+        # Get patterns from registry
+        date_patterns = self.config_manager.pattern_registry.get('dates', [])
+        
+        # Patterns to ignore (aviation references)
+        ignore_patterns = [
+            r'\bAD \d{4}-\d{2}-\d{2}\b',      # Airworthiness Directive references
+            r'\bSWPM \d{2}-\d{2}-\d{2}\b',    # Standard Wiring Practices Manual references
+            r'\bAMM \d{2}-\d{2}-\d{2}\b',     # Aircraft Maintenance Manual references
+            r'\bSOPM \d{2}-\d{2}-\d{2}\b',    # Standard Operating Procedure references
+            r'\b[A-Z]{2,4} \d{2}-\d{2}-\d{2}\b'  # Generic manual reference pattern
+        ]
+        
+        # Combine ignore patterns into one
+        ignore_regex = '|'.join(f'(?:{pattern})' for pattern in ignore_patterns)
+        ignore_pattern = re.compile(ignore_regex)
+        
+        # Track unique issues
+        unique_issues = []
+        
+        # Use _process_sentences helper
+        for sentence, paragraph in self._process_sentences(doc, skip_empty=True, skip_headings=True):
+            # First, identify and temporarily remove text that should be ignored
+            working_sentence = sentence
+            
+            # Find all matches to ignore
+            ignored_matches = list(ignore_pattern.finditer(sentence))
+            
+            # Replace ignored patterns with placeholders
+            for match in reversed(ignored_matches):
+                start, end = match.span()
+                working_sentence = working_sentence[:start] + 'X' * (end - start) + working_sentence[end:]
+            
+            # Now check for date patterns in the modified sentence
+            for pattern_config in date_patterns:
+                matches = list(re.finditer(pattern_config.pattern, working_sentence))
+                
+                for match in matches:
+                    # Get the original text from the match position
+                    original_date = sentence[match.start():match.end()]
+                    
+                    # Create formatted issue with incorrect/correct format
+                    formatted_issue = {
+                        'incorrect': original_date,
+                        'correct': 'Month Day, Year'
+                    }
+                    unique_issues.append(formatted_issue)
+
+        return DocumentCheckResult(success=len(unique_issues) == 0, issues=unique_issues)
+
+    @profile_performance
+    def check_placeholders(self, doc: List[str]) -> DocumentCheckResult:
+        """Check for placeholders that should be removed."""
+        def process_placeholders(doc: List[str], patterns: List[PatternConfig]) -> DocumentCheckResult:
+            tbd_placeholders = []
+            to_be_determined_placeholders = []
+            to_be_added_placeholders = []
+            
+            pattern_categories = {
+                r'\bTBD\b': ('tbd', tbd_placeholders),
+                r'\bTo be determined\b': ('to_be_determined', to_be_determined_placeholders),
+                r'\bTo be added\b': ('to_be_added', to_be_added_placeholders)
+            }
+
+            # Use _process_sentences helper
+            for sentence, paragraph in self._process_sentences(doc, skip_empty=True, skip_headings=True):
+                for pattern_config in patterns:
+                    compiled_pattern = re.compile(pattern_config.pattern, re.IGNORECASE)
+                    
+                    for pattern_key, (category_name, category_list) in pattern_categories.items():
+                        if pattern_config.pattern == pattern_key:
+                            matches = compiled_pattern.finditer(sentence)
+                            for match in matches:
+                                category_list.append({
+                                    'placeholder': match.group().strip(),
+                                    'sentence': sentence.strip(),
+                                    'description': pattern_config.description
+                                })
+
+            # Compile issues
+            issues = []
+            if tbd_placeholders:
+                issues.append({
+                    'issue_type': 'tbd_placeholder',
+                    'description': 'Remove TBD placeholder',
+                    'occurrences': tbd_placeholders
+                })
+                
+            if to_be_determined_placeholders:
+                issues.append({
+                    'issue_type': 'to_be_determined_placeholder',
+                    'description': "Remove 'To be determined' placeholder",
+                    'occurrences': to_be_determined_placeholders
+                })
+                
+            if to_be_added_placeholders:
+                issues.append({
+                    'issue_type': 'to_be_added_placeholder',
+                    'description': "Remove 'To be added' placeholder",
+                    'occurrences': to_be_added_placeholders
+                })
+
+            details = {
+                'total_placeholders': len(tbd_placeholders) + 
+                                    len(to_be_determined_placeholders) + 
+                                    len(to_be_added_placeholders),
+                'placeholder_types': {
+                    'TBD': len(tbd_placeholders),
+                    'To be determined': len(to_be_determined_placeholders),
+                    'To be added': len(to_be_added_placeholders)
+                }
+            }
+
+            return DocumentCheckResult(success=len(issues) == 0, issues=issues, details=details)
+
+        return self._process_patterns(doc, 'placeholders', process_placeholders)
+
+    @profile_performance
+    def _process_patterns(
+        self,
+        doc: List[str],
+        pattern_category: str,
+        process_func: Optional[Callable] = None
+    ) -> DocumentCheckResult:
+        """
+        Process document text against patterns from a specific category.
+        
+        Args:
+            doc: List of document paragraphs
+            pattern_category: Category of patterns to check against
+            process_func: Optional custom processing function
+            
+        Returns:
+            DocumentCheckResult with processed issues
+        """
+        if not self.validate_input(doc):
+            self.logger.error("Invalid document input for pattern check")
+            return DocumentCheckResult(
+                success=False, 
+                issues=[{'error': 'Invalid document input'}]
+            )
+
+        # Get patterns from registry
+        patterns = self.config_manager.pattern_registry.get(pattern_category, [])
+        if not patterns:
+            self.logger.warning(f"No patterns found for category: {pattern_category}")
+            return DocumentCheckResult(
+                success=True,
+                issues=[],
+                details={'message': f'No patterns defined for {pattern_category}'}
+            )
+
+        # Use custom processing function if provided
+        if process_func:
+            return process_func(doc, patterns)
+
+        # Default processing with deduplication
+        unique_issues = set()  # Using a set to track unique issues
+
+        for paragraph in doc:
+            sentences = re.split(r'(?<=[.!?])\s+', paragraph)
+            for sentence in sentences:
+                sentence = sentence.strip()
+                if not sentence:
+                    continue
+                    
+                for pattern_config in patterns:
+                    matches = list(re.finditer(pattern_config.pattern, sentence))
+                    if matches:
+                        # Add each match as a tuple to ensure uniqueness
+                        for match in matches:
+                            unique_issues.add((
+                                match.group(),  # The matched text
+                                pattern_config.description,  # The issue description
+                                pattern_config.replacement if hasattr(pattern_config, 'replacement') else None
+                            ))
+
+        # Convert unique issues back to the expected format
+        formatted_issues = [
+            {
+                'incorrect': issue[0],
+                'description': issue[1],
+                'replacement': issue[2]
+            }
+            for issue in sorted(unique_issues)  # Sort for consistent output
+        ]
+
+        return DocumentCheckResult(success=len(formatted_issues) == 0, issues=formatted_issues)
+
+    @profile_performance
+    def check_paragraph_length(self, doc: List[str]) -> DocumentCheckResult:
+        """
+        Check for overly long paragraphs that may need to be split up.
+        
+        Args:
+            doc (List[str]): List of document paragraphs
+            
+        Returns:
+            DocumentCheckResult: Results of paragraph length check
+        """
+        if not self.validate_input(doc):
+            return DocumentCheckResult(success=False, issues=[{'error': 'Invalid document input'}])
+            
+        issues = []
+        
+        for paragraph in doc:
+            if not paragraph.strip():  # Skip empty paragraphs
+                continue
+                
+            # Count sentences (split on period, exclamation, question mark followed by space)
+            sentences = re.split(r'(?<=[.!?])\s+', paragraph.strip())
+            # Count lines (split on newlines or when length exceeds ~80 characters)
+            lines = []
+            current_line = ""
+            
+            for word in paragraph.split():
+                if len(current_line) + len(word) + 1 <= 80:
+                    current_line += " " + word if current_line else word
+                else:
+                    lines.append(current_line)
+                    current_line = word
+            if current_line:
+                lines.append(current_line)
+            
+            # Check if paragraph exceeds either threshold
+            if len(sentences) > 6 or len(lines) > 8:
+                # Get first sentence for context
+                first_sentence = sentences[0].strip()
+                issues.append(f"Review the paragraph that starts with: \"{first_sentence}\"")
+        
+        return DocumentCheckResult(success=len(issues) == 0, issues=issues)
+    
+    @profile_performance
+    def check_sentence_length(self, doc: List[str]) -> DocumentCheckResult:
+        """
+        Check for overly long sentences that may need to be split for clarity.
+        
+        Args:
+            doc (List[str]): List of document paragraphs
+            
+        Returns:
+            DocumentCheckResult: Results of sentence length check including:
+                - success: Boolean indicating if all sentences are acceptable length
+                - issues: List of dicts with long sentence details
+                - details: Additional statistics about sentence lengths
+        """
+        if not self.validate_input(doc):
+            return DocumentCheckResult(success=False, issues=[{'error': 'Invalid document input'}])
+            
+        issues = []
+        sentence_stats = {
+            'total_sentences': 0,
+            'long_sentences': 0,
+            'max_length': 0,
+            'avg_length': 0
+        }
+        
+        # Skip patterns for technical content that might naturally be longer
+        skip_patterns = [
+            r'^(?:Note:|Warning:|Caution:)',  # Notes and warnings
+            r'^\d+\.',  # Numbered lists
+            r'^\([a-z]\)',  # Letter lists
+            r'^\([0-9]\)',  # Number lists in parentheses
+            r'^Table \d',  # Table captions
+            r'^Figure \d',  # Figure captions
+            r'(?:e\.g\.|i\.e\.|viz\.,)',  # Latin abbreviations often used in complex sentences
+            r'\b(?:AC|AD|TSO|SFAR)\s+\d',  # Technical references
+            r'\d+\s*(?:CFR|U\.S\.C\.)',  # Regulatory references
+        ]
+        skip_regex = re.compile('|'.join(skip_patterns), re.IGNORECASE)
+        
+        total_words = 0
+        
+        for paragraph in doc:
+            if not paragraph.strip():
+                continue
+                
+            # Skip if paragraph matches any skip patterns
+            if skip_regex.search(paragraph):
+                continue
+                
+            # Split into sentences while preserving punctuation
+            sentences = re.split(r'(?<=[.!?])\s+', paragraph.strip())
+            
+            for sentence in sentences:
+                sentence = sentence.strip()
+                if not sentence:
+                    continue
+                    
+                # Count words (splitting on whitespace)
+                words = sentence.split()
+                word_count = len(words)
+                
+                sentence_stats['total_sentences'] += 1
+                total_words += word_count
+                
+                if word_count > sentence_stats['max_length']:
+                    sentence_stats['max_length'] = word_count
+                
+                # Flag sentences over 35 words
+                if word_count > 35:
+                    sentence_stats['long_sentences'] += 1
+                    issues.append({
+                        'sentence': sentence,
+                        'word_count': word_count
+                    })
+        
+        # Calculate average sentence length
+        if sentence_stats['total_sentences'] > 0:
+            sentence_stats['avg_length'] = round(total_words / sentence_stats['total_sentences'], 1)
+        
+        return DocumentCheckResult(
+            success=len(issues) == 0,
+            issues=issues,
+            details=sentence_stats
+        )
+
 class DocumentCheckResultsFormatter:
     
     def __init__(self):
@@ -1890,7 +2255,7 @@ class DocumentCheckResultsFormatter:
             'heading_title_period_check': {
                 'title': 'Heading Period Format',
                 'description': 'Examines heading punctuation to ensure compliance with FAA document formatting standards. Some FAA documents (like Advisory Circulars and Orders) require periods at the end of headings, while others (like Federal Register Notices) don\'t.',
-                'solution': 'Format heading periods according to document type requirements',
+                'solution': 'Format heading periods according to document type requirements.',
                 'example_fix': {
                     'before': 'Purpose',
                     'after': 'Purpose.' # For ACs and Orders
@@ -1899,7 +2264,7 @@ class DocumentCheckResultsFormatter:
             'table_figure_reference_check': {
                 'title': 'Table and Figure References',
                 'description': 'Analyzes how tables and figures are referenced within your document text. Capitalize references at the beginning of sentences (e.g., "Table 2-1 shows...") and use lowercase references within sentences (e.g., "...as shown in table 2-1").',
-                'solution': 'Capitalize references at start of sentences, use lowercase within sentences',
+                'solution': 'Capitalize references at start of sentences, use lowercase within sentences.',
                 'example_fix': {
                     'before': 'The DTR values are specified in Table 3-1 and Figure 3-2.',
                     'after': 'The DTR values are specified in table 3-1 and figure 3-2.'
@@ -1908,7 +2273,7 @@ class DocumentCheckResultsFormatter:
             'acronym_check': {
                 'title': 'Acronym Definition Issues',
                 'description': 'Ensures every acronym is properly introduced with its full term at first use. The check identifies undefined acronyms while recognizing common exceptions (like U.S.) that don\'t require definition.',
-                'solution': 'Define each acronym at its first use, e.g., "Federal Aviation Administration (FAA)"',
+                'solution': 'Define each acronym at its first use, e.g., "Federal Aviation Administration (FAA)".',
                 'example_fix': {
                     'before': 'This order establishes general FAA organizational policies.',
                     'after': 'This order establishes general Federal Aviation Administration (FAA) organizational policies.'
@@ -1926,7 +2291,7 @@ class DocumentCheckResultsFormatter:
             'terminology_check': {
                 'title': 'Incorrect Terminology',
                 'description': 'Evaluates document text against the various style manuals and orders to identify non-compliant terminology, ambiguous references, and outdated phrases. This includes checking for prohibited relative references (like "above" or "below"), proper legal terminology (like "must" instead of "shall"), and consistent formatting of regulatory citations.',
-                'solution': 'Use explicit references to paragraphs, sections, tables, and figures',
+                'solution': 'Use explicit references to paragraphs, sections, tables, and figures.',
                 'example_fix': {
                     'before': 'Operators shall comply with ADs to ensure aircraft safety and regulatory compliance',
                     'after': 'Operators must comply with ADs to ensure aircraft safety and regulatory compliance.'
@@ -1935,7 +2300,7 @@ class DocumentCheckResultsFormatter:
             'section_symbol_usage_check': {
                 'title': 'Section Symbol (§) Format Issues',
                 'description': 'Examines the usage of section symbols (§) throughout your document. This includes verifying proper symbol placement in regulatory references, ensuring sections aren\'t started with the symbol, checking consistency in multiple-section citations, and validating proper CFR citations. For ACs, see FAA Order 1320.46.',
-                'solution': 'Format section symbols correctly and never start sentences with them',
+                'solution': 'Format section symbols correctly and never start sentences with them.',
                 'example_fix': {
                     'before': '§ 23.3 establishes design criteria.',
                     'after': 'Section 23.3 establishes design criteria.'
@@ -1944,7 +2309,7 @@ class DocumentCheckResultsFormatter:
             'double_period_check': {
                 'title': 'Multiple Period Issues',
                 'description': 'Examines sentences for accidental double periods that often occur during document editing and revision. While double periods are sometimes found in ellipses (...) or web addresses, they should never appear at the end of standard sentences in FAA documentation.',
-                'solution': 'Remove multiple periods that end sentences',
+                'solution': 'Remove multiple periods that end sentences.',
                 'example_fix': {
                     'before': 'The following ACs are related to the guidance in this document..',
                     'after': 'The following ACs are related to the guidance in this document.'
@@ -1971,7 +2336,7 @@ class DocumentCheckResultsFormatter:
             'placeholders_check': {
                 'title': 'Placeholder Content',
                 'description': 'Identifies incomplete content and temporary placeholders that must be finalized before document publication. This includes common placeholder text (like "TBD" or "To be determined"), draft markers, and incomplete sections.',
-                'solution': 'Replace all placeholder content with actual content',
+                'solution': 'Replace all placeholder content with actual content.',
                 'example_fix': {
                     'before': 'Pilots must submit the [Insert text] form to the FAA for approval.',
                     'after': 'Pilots must submit the Report of Eye Evaluation form 8500-7 to the FAA for approval.'
@@ -1980,11 +2345,29 @@ class DocumentCheckResultsFormatter:
             'parentheses_check': {
                 'title': 'Parentheses Balance Check',
                 'description': 'Ensures that all parentheses in the document are properly paired with matching opening and closing characters.',
-                'solution': 'Add missing opening or closing parentheses where indicated',
+                'solution': 'Add missing opening or closing parentheses where indicated.',
                 'example_fix': {
                     'before': 'The system (as defined in AC 25-11B performs...',
                     'after': 'The system (as defined in AC 25-11B) performs...'
                 }
+            },
+            'paragraph_length_check': {
+                'title': 'Paragraph Length Issues',
+                'description': 'Flags paragraphs exceeding 6 sentences or 8 lines to enhance readability and clarity. While concise paragraphs are encouraged, with each focusing on a single idea or related points, exceeding these limits doesn\'t necessarily indicate a problem. Some content may appropriately extend beyond 8 lines, especially if it includes necessary details. Boilerplate language or template text exceeding these limits is not subject to modification or division.',
+                'solution': 'Where possible, split long paragraphs into smaller sections, ensuring each focuses on one primary idea. If restructuring is not feasible or the content is boilerplate text, no changes are needed.',
+                'example_fix': {
+                    'before': 'A very long paragraph covering multiple topics and spanning many lines...',
+                    'after': 'Multiple shorter paragraphs or restructured paragraphs, each focused on a single topic or related points.'
+                }
+            },
+            'sentence_length_check': {
+                'title': 'Sentence Length Issues',
+                'description': 'Analyzes sentence length to ensure readability. While the ideal length varies with content complexity, sentences over 35 words often become difficult to follow. Technical content, regulatory references, notes, warnings, and list items are excluded from this check.',
+                'solution': 'Break long sentences into smaller ones where possible, focusing on one main point per sentence. Consider using lists for complex items.',
+                'example_fix': {
+                    'before': 'The operator must ensure that all required maintenance procedures are performed in accordance with the manufacturer\'s specifications and that proper documentation is maintained throughout the entire process to demonstrate compliance with regulatory requirements.',
+                    'after': 'The operator must ensure all required maintenance procedures are performed according to manufacturer specifications. Additionally, proper documentation must be maintained to demonstrate regulatory compliance.'
+                }
             }
         }
 
@@ -2093,12 +2476,18 @@ class DocumentCheckResultsFormatter:
         if 'incorrect_term' in issue and 'correct_term' in issue:
             return f"    • Replace '{issue['incorrect_term']}' with '{issue['correct_term']}'"
         
+        if 'sentence' in issue and 'word_count' in issue:  # For sentence length check
+            return f"    • Review this sentence: \"{issue['sentence']}\""
+        
         if 'sentence' in issue:
             return f"    • {issue['sentence']}"
         
         if 'description' in issue:
             return f"    • {issue['description']}"
         
+        if 'type' in issue and issue['type'] == 'long_paragraph':
+            return f"    • {issue['message']}"
+        
         # Fallback for other issue formats
         return f"    • {str(issue)}"
 
@@ -2324,12 +2713,14 @@ class DocumentCheckResultsFormatter:
                     output.extend(self._format_section_symbol_issues(result))
                 elif check_name == 'parentheses_check':
                     output.extend(self._format_parentheses_issues(result))
+                elif check_name == 'paragraph_length_check':
+                    output.extend(self._format_paragraph_length_issues(result))
                 else:
-                    formatted_issues = [self._format_standard_issue(issue) for issue in result.issues[:10]]
+                    formatted_issues = [self._format_standard_issue(issue) for issue in result.issues[:15]]
                     output.extend(formatted_issues)
                     
                     if len(result.issues) > 10:
-                        output.append(f"\n    ... and {len(result.issues) - 10} more similar issues.")
+                        output.append(f"\n    ... and {len(result.issues) - 15} more similar issues.")
         
         return '\n'.join(output)
 
@@ -2401,18 +2792,21 @@ def format_markdown_results(results: Dict[str, DocumentCheckResult], doc_type: s
     check_categories = {
         'heading_title_check': {'title': '📋 Required Headings', 'priority': 1},
         'heading_title_period_check': {'title': '🔍 Heading Period Usage', 'priority': 1},
-        'acronym_check': {'title': '📝 Acronym Definitions', 'priority': 2},
-        'terminology_check': {'title': '📖 Terminology Usage', 'priority': 2},
+        'terminology_check': {'title': '📖 Terminology Usage', 'priority': 1},
+        'acronym_check': {'title': '📝 Acronym Definitions', 'priority': 1},
+        'acronym_usage_check': {'title': '📎 Acronym Usage', 'priority': 1},
         'section_symbol_usage_check': {'title': '§ Section Symbol Usage', 'priority': 2},
+        'date_formats_check': {'title': '📅 Date Formats', 'priority': 2},
+        'placeholders_check': {'title': '🚩 Placeholder Content', 'priority': 2},
+        'document_title_check': {'title': '📑 Document Title Format', 'priority': 2},
         'caption_check_table': {'title': '📊 Table Captions', 'priority': 3},
         'caption_check_figure': {'title': '🖼️ Figure Captions', 'priority': 3},
         'table_figure_reference_check': {'title': '🔗 Table/Figure References', 'priority': 3},
-        'document_title_check': {'title': '📑 Document Title Format', 'priority': 1},
+        'parentheses_check': {'title': '🔗 Parentheses Usage', 'priority': 4},
         'double_period_check': {'title': '⚡ Double Periods', 'priority': 4},
         'spacing_check': {'title': '⌨️ Spacing Issues', 'priority': 4},
-        'abbreviation_usage_check': {'title': '📎 Abbreviation Usage', 'priority': 3},
-        'date_formats_check': {'title': '📅 Date Formats', 'priority': 3},
-        'placeholders_check': {'title': '🚩 Placeholder Content', 'priority': 1}
+        'paragraph_length_check': {'title': '📏 Paragraph Length', 'priority': 5},
+        'sentence_length_check': {'title': '📏 Sentence Length', 'priority': 5}
     }
 
     sorted_checks = sorted(