elspais 0.11.1__py3-none-any.whl → 0.11.2__py3-none-any.whl

elspais/commands/reformat_cmd.py

@@ -15,11 +15,11 @@ import argparse
 import shutil
 import sys
 from pathlib import Path
-from typing import List, Optional
+from typing import Optional
 
-from elspais.config.loader import load_config, find_config_file, get_spec_directories
+from elspais.config.loader import find_config_file, get_spec_directories, load_config
 from elspais.core.parser import RequirementParser
-from elspais.core.patterns import PatternValidator, PatternConfig
+from elspais.core.patterns import PatternConfig, PatternValidator
 from elspais.core.rules import RuleEngine, RulesConfig
 
 
@@ -30,15 +30,14 @@ def run(args: argparse.Namespace) -> int:
     to the new Assertions format using Claude AI.
     """
     from elspais.reformat import (
-        get_all_requirements,
+        assemble_new_format,
         build_hierarchy,
-        traverse_top_down,
+        get_all_requirements,
+        normalize_line_breaks,
         normalize_req_id,
         reformat_requirement,
-        assemble_new_format,
+        traverse_top_down,
         validate_reformatted_content,
-        normalize_line_breaks,
-        fix_requirement_line_breaks,
     )
 
     print("elspais reformat-with-claude")
@@ -55,10 +54,10 @@ def run(args: argparse.Namespace) -> int:
     backup = args.backup
     force = args.force
     fix_line_breaks = args.fix_line_breaks
-    verbose = getattr(args, 'verbose', False)
-    mode = getattr(args, 'mode', 'combined')
+    verbose = getattr(args, "verbose", False)
+    mode = getattr(args, "mode", "combined")
 
-    print(f"Options:")
+    print("Options:")
     print(f"  Start REQ:       {start_req or 'All PRD requirements'}")
     print(f"  Max depth:       {max_depth or 'Unlimited'}")
     print(f"  Mode:            {mode}")
@@ -86,8 +85,7 @@ def run(args: argparse.Namespace) -> int:
     requirements = get_all_requirements(mode=mode)
     if not requirements:
         print("FAILED")
-        print("Error: Could not load requirements. Run 'elspais validate' first.",
-              file=sys.stderr)
+        print("Error: Could not load requirements. Run 'elspais validate' first.", file=sys.stderr)
         return 1
     print(f"found {len(requirements)} requirements")
 
@@ -108,13 +106,10 @@ def run(args: argparse.Namespace) -> int:
 
         print(f"Traversing from {start_req}...", flush=True)
         req_ids = traverse_top_down(requirements, start_req, max_depth)
-        print(f"Traversal complete", flush=True)
+        print("Traversal complete", flush=True)
     else:
         # Process all PRD requirements first, then their descendants
-        prd_reqs = [
-            req_id for req_id, node in requirements.items()
-            if node.level.upper() == 'PRD'
-        ]
+        prd_reqs = [req_id for req_id, node in requirements.items() if node.level.upper() == "PRD"]
         prd_reqs.sort()
 
         print(f"Processing {len(prd_reqs)} PRD requirements and their descendants...")
@@ -167,8 +162,8 @@ def run(args: argparse.Namespace) -> int:
             continue
 
         # Validate the result
-        rationale = result.get('rationale', '')
-        assertions = result.get('assertions', [])
+        rationale = result.get("rationale", "")
+        assertions = result.get("assertions", [])
 
         is_valid, warnings = validate_reformatted_content(node, rationale, assertions)
 
@@ -177,7 +172,7 @@ def run(args: argparse.Namespace) -> int:
                 print(f"  WARNING: {warning}")
 
         if not is_valid:
-            print(f"  INVALID: Skipping due to validation errors")
+            print("  INVALID: Skipping due to validation errors")
             errors += 1
             continue
 
@@ -189,7 +184,7 @@ def run(args: argparse.Namespace) -> int:
             status=node.status,
             implements=node.implements,
             rationale=rationale,
-            assertions=assertions
+            assertions=assertions,
         )
 
         # Optionally normalize line breaks
@@ -207,7 +202,7 @@ def run(args: argparse.Namespace) -> int:
                 file_path = Path(node.file_path)
 
                 if backup:
-                    backup_path = file_path.with_suffix(file_path.suffix + '.bak')
+                    backup_path = file_path.with_suffix(file_path.suffix + ".bak")
                     shutil.copy2(file_path, backup_path)
                     print(f"  Backup: {backup_path}")
 
@@ -226,7 +221,7 @@ def run(args: argparse.Namespace) -> int:
                     print(f"  Written: {file_path}")
                     reformatted += 1
                 else:
-                    print(f"  ERROR: Could not locate requirement in file")
+                    print("  ERROR: Could not locate requirement in file")
                     errors += 1
 
             except Exception as e:
@@ -236,7 +231,7 @@ def run(args: argparse.Namespace) -> int:
     # Summary
     print()
     print("=" * 60)
-    print(f"Summary:")
+    print("Summary:")
     print(f"  Reformatted: {reformatted}")
     print(f"  Skipped:     {skipped}")
     print(f"  Errors:      {errors}")
@@ -247,10 +242,7 @@ def run(args: argparse.Namespace) -> int:
 
 
 def replace_requirement_content(
-    file_content: str,
-    req_id: str,
-    title: str,
-    new_content: str
+    file_content: str, req_id: str, title: str, new_content: str
 ) -> Optional[str]:
     """
     Replace a requirement's content in a file.
@@ -271,13 +263,13 @@ def replace_requirement_content(
 
     # Pattern to match the requirement header
     # # REQ-d00027: Title
-    header_pattern = rf'^# {re.escape(req_id)}:\s*'
+    header_pattern = rf"^# {re.escape(req_id)}:\s*"
 
     # Pattern to match the footer
     # *End* *Title* | **Hash**: xxxxxxxx
-    footer_pattern = rf'^\*End\*\s+\*{re.escape(title)}\*\s+\|\s+\*\*Hash\*\*:\s*[a-fA-F0-9]+'
+    footer_pattern = rf"^\*End\*\s+\*{re.escape(title)}\*\s+\|\s+\*\*Hash\*\*:\s*[a-fA-F0-9]+"
 
-    lines = file_content.split('\n')
+    lines = file_content.split("\n")
     result_lines = []
     in_requirement = False
     found = False
@@ -292,7 +284,7 @@ def replace_requirement_content(
                 in_requirement = True
                 found = True
                 # Insert new content (without trailing newline, we'll add it)
-                new_lines = new_content.rstrip('\n').split('\n')
+                new_lines = new_content.rstrip("\n").split("\n")
                 result_lines.extend(new_lines)
                 i += 1
                 continue
@@ -307,7 +299,7 @@ def replace_requirement_content(
                 in_requirement = False
                 i += 1
                 # Skip any trailing blank lines after the footer
-                while i < len(lines) and lines[i].strip() == '':
+                while i < len(lines) and lines[i].strip() == "":
                     i += 1
             else:
                 # Skip this line (part of old requirement)
@@ -316,15 +308,15 @@ def replace_requirement_content(
     if not found:
         return None
 
-    return '\n'.join(result_lines)
+    return "\n".join(result_lines)
 
 
 def run_line_breaks_only(args: argparse.Namespace) -> int:
     """Run line break normalization only."""
     from elspais.reformat import (
+        detect_line_break_issues,
         get_all_requirements,
         normalize_line_breaks,
-        detect_line_break_issues,
     )
 
     dry_run = args.dry_run
@@ -358,7 +350,7 @@ def run_line_breaks_only(args: argparse.Namespace) -> int:
     unchanged = 0
     errors = 0
 
-    for file_path_str, req_ids in sorted(files_to_process.items()):
+    for file_path_str, _req_ids in sorted(files_to_process.items()):
         file_path = Path(file_path_str)
 
         try:
@@ -381,7 +373,7 @@ def run_line_breaks_only(args: argparse.Namespace) -> int:
             fixed_content = normalize_line_breaks(content)
 
             if backup:
-                backup_path = file_path.with_suffix(file_path.suffix + '.bak')
+                backup_path = file_path.with_suffix(file_path.suffix + ".bak")
                 shutil.copy2(file_path, backup_path)
 
             file_path.write_text(fixed_content)
@@ -393,7 +385,7 @@ def run_line_breaks_only(args: argparse.Namespace) -> int:
 
     print()
     print("=" * 60)
-    print(f"Summary:")
+    print("Summary:")
     print(f"  Fixed:     {fixed}")
     print(f"  Unchanged: {unchanged}")
     print(f"  Errors:    {errors}")
@@ -435,10 +427,7 @@ def get_requirements_needing_reformat(config: dict, base_path: Path) -> set:
     violations = engine.validate(requirements)
 
     # Filter to acceptance_criteria violations
-    return {
-        v.requirement_id for v in violations
-        if v.rule_name == "format.acceptance_criteria"
-    }
+    return {v.requirement_id for v in violations if v.rule_name == "format.acceptance_criteria"}
 
 
 def is_local_file(file_path: str, base_path: Path) -> bool:

elspais/commands/rules_cmd.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from typing import Optional
 
 from elspais.config.loader import find_config_file, load_config
-from elspais.core.content_rules import load_content_rules, load_content_rule
+from elspais.core.content_rules import load_content_rule, load_content_rules
 
 
 def run(args: argparse.Namespace) -> int:
@@ -56,7 +56,11 @@ def cmd_list(args: argparse.Namespace) -> int:
     print("Content Rules:")
     print("-" * 60)
     for rule in rules:
-        rel_path = rule.file_path.relative_to(base_path) if base_path in rule.file_path.parents else rule.file_path
+        rel_path = (
+            rule.file_path.relative_to(base_path)
+            if base_path in rule.file_path.parents
+            else rule.file_path
+        )
         print(f"  {rel_path}")
         print(f"    Title: {rule.title}")
         print(f"    Type: {rule.type}")

elspais/commands/trace.py

@@ -24,11 +24,11 @@ def run(args: argparse.Namespace) -> int:
     """
     # Check if enhanced trace-view features are requested
     use_trace_view = (
-        getattr(args, 'view', False) or
-        getattr(args, 'embed_content', False) or
-        getattr(args, 'edit_mode', False) or
-        getattr(args, 'review_mode', False) or
-        getattr(args, 'server', False)
+        getattr(args, "view", False)
+        or getattr(args, "embed_content", False)
+        or getattr(args, "edit_mode", False)
+        or getattr(args, "review_mode", False)
+        or getattr(args, "server", False)
     )
 
     if use_trace_view:
@@ -119,7 +119,7 @@ def run_trace_view(args: argparse.Namespace) -> int:
     except ImportError as e:
         print("Error: trace-view features require additional dependencies.", file=sys.stderr)
         print("Install with: pip install elspais[trace-view]", file=sys.stderr)
-        if args.verbose if hasattr(args, 'verbose') else False:
+        if args.verbose if hasattr(args, "verbose") else False:
             print(f"Import error: {e}", file=sys.stderr)
         return 1
 
@@ -151,8 +151,8 @@ def run_trace_view(args: argparse.Namespace) -> int:
     generator = TraceViewGenerator(
         spec_dir=spec_dir,
         impl_dirs=impl_dirs,
-        sponsor=getattr(args, 'sponsor', None),
-        mode=getattr(args, 'mode', 'core'),
+        sponsor=getattr(args, "sponsor", None),
+        mode=getattr(args, "mode", "core"),
         repo_root=repo_root,
         config=config,
     )
@@ -174,13 +174,13 @@ def run_trace_view(args: argparse.Namespace) -> int:
             output_file = Path("traceability_matrix.md")
 
     # Generate
-    quiet = getattr(args, 'quiet', False)
+    quiet = getattr(args, "quiet", False)
     generator.generate(
         format=output_format,
         output_file=output_file,
-        embed_content=getattr(args, 'embed_content', False),
-        edit_mode=getattr(args, 'edit_mode', False),
-        review_mode=getattr(args, 'review_mode', False),
+        embed_content=getattr(args, "embed_content", False),
+        edit_mode=getattr(args, "edit_mode", False),
+        review_mode=getattr(args, "review_mode", False),
         quiet=quiet,
     )
 
@@ -194,7 +194,7 @@ def run_review_server(args: argparse.Namespace) -> int:
                       elspais[trace-review] extra.
     """
     try:
-        from elspais.trace_view.review import create_app, FLASK_AVAILABLE
+        from elspais.trace_view.review import FLASK_AVAILABLE, create_app
     except ImportError:
         print("Error: Review server requires additional dependencies.", file=sys.stderr)
         print("Install with: pip install elspais[trace-review]", file=sys.stderr)
@@ -212,9 +212,10 @@ def run_review_server(args: argparse.Namespace) -> int:
     else:
         repo_root = Path.cwd()
 
-    port = getattr(args, 'port', 8080)
+    port = getattr(args, "port", 8080)
 
-    print(f"""
+    print(
+        f"""
 ======================================
   elspais Review Server
 ======================================
@@ -223,11 +224,12 @@ Repository: {repo_root}
 Server:     http://localhost:{port}
 
 Press Ctrl+C to stop
-""")
+"""
+    )
 
     app = create_app(repo_root, auto_sync=True)
     try:
-        app.run(host='0.0.0.0', port=port, debug=False)
+        app.run(host="0.0.0.0", port=port, debug=False)
     except KeyboardInterrupt:
         print("\nServer stopped.")
 
@@ -323,7 +325,7 @@ def generate_html_matrix(requirements: Dict[str, Requirement]) -> str:
             status_class = f"status-{req.status.lower()}"
             subdir_attr = f'data-subdir="{req.subdir}"'
             html += (
-                f'        <tr {subdir_attr}><td>{req_id}</td><td>{req.title}</td>'
+                f"        <tr {subdir_attr}><td>{req_id}</td><td>{req.title}</td>"
                 f'<td>{impl_str}</td><td class="{status_class}">{req.status}</td></tr>\n'
             )
 
@@ -343,7 +345,9 @@ def generate_csv_matrix(requirements: Dict[str, Requirement]) -> str:
     for req_id, req in sorted(requirements.items()):
         impl_str = ";".join(req.implements) if req.implements else ""
         title = req.title.replace('"', '""')
-        lines.append(f'"{req_id}","{title}","{req.level}","{req.status}","{impl_str}","{req.subdir}"')
+        lines.append(
+            f'"{req_id}","{title}","{req.level}","{req.status}","{impl_str}","{req.subdir}"'
+        )
 
     return "\n".join(lines)
 

elspais/commands/validate.py

@@ -43,10 +43,10 @@ def run(args: argparse.Namespace) -> int:
         return 1
 
     # Add sponsor spec directories if mode is "combined" and include_associated is enabled
-    mode = getattr(args, 'mode', 'combined')
-    include_associated = config.get('traceability', {}).get('include_associated', True)
+    mode = getattr(args, "mode", "combined")
+    include_associated = config.get("traceability", {}).get("include_associated", True)
 
-    if mode == 'combined' and include_associated:
+    if mode == "combined" and include_associated:
         base_path = find_project_root(spec_dirs)
         sponsor_dirs = get_sponsor_spec_directories(config, base_path)
         if sponsor_dirs:
@@ -103,12 +103,11 @@ def run(args: argparse.Namespace) -> int:
     # Filter skipped rules
     if args.skip_rule:
         violations = [
-            v for v in violations
-            if not any(skip in v.rule_name for skip in args.skip_rule)
+            v for v in violations if not any(skip in v.rule_name for skip in args.skip_rule)
         ]
 
     # JSON output mode - output and exit
-    if getattr(args, 'json', False):
+    if getattr(args, "json", False):
         # Test mapping (if enabled)
         test_data = None
         testing_config = TestingConfig.from_dict(config.get("testing", {}))
@@ -191,9 +190,9 @@ def should_scan_tests(args: argparse.Namespace, config: TestingConfig) -> bool:
     Returns:
         True if test scanning should run
     """
-    if getattr(args, 'no_tests', False):
+    if getattr(args, "no_tests", False):
         return False
-    if getattr(args, 'tests', False):
+    if getattr(args, "tests", False):
         return True
     return config.enabled
 
@@ -409,8 +408,7 @@ def format_requirements_json(
                 cycle_path = v.message
 
         # Build requirement data matching hht_diary format
-        # Use the original ID (strip __conflict suffix) for output key
-        output_key = req_id.replace("__conflict", "") if req.is_conflict else req_id
+        # Note: req_id includes __conflict suffix for conflicts to avoid key collision
         output[req_id] = {
             "title": req.title,
             "status": req.status,

elspais/config/defaults.py

@@ -96,7 +96,13 @@ DEFAULT_CONFIG = {
             "labels_sequential": True,
             "labels_unique": True,
             "placeholder_values": [
-                "obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"
+                "obsolete",
+                "removed",
+                "deprecated",
+                "N/A",
+                "n/a",
+                "-",
+                "reserved",
             ],
         },
         "traceability": {

elspais/core/content_rules.py

@@ -5,7 +5,6 @@ Content rules are markdown files that provide semantic validation guidance
 for requirements authoring. They can include YAML frontmatter for metadata.
 """
 
-import re
 from pathlib import Path
 from typing import Any, Dict, List, Tuple
 

elspais/core/git.py

@@ -123,9 +123,7 @@ def get_modified_files(repo_root: Path) -> Tuple[Set[str], Set[str]]:
         return set(), set()
 
 
-def get_changed_vs_branch(
-    repo_root: Path, base_branch: str = "main"
-) -> Set[str]:
+def get_changed_vs_branch(repo_root: Path, base_branch: str = "main") -> Set[str]:
     """Get set of files changed between current branch and base branch.
 
     Args:
@@ -181,9 +179,7 @@ def get_committed_req_locations(
 
     req_locations: Dict[str, str] = {}
     # Pattern matches REQ headers with optional associated prefix
-    req_pattern = re.compile(
-        r"^#{1,6}\s+REQ-(?:[A-Z]{2,4}-)?([pod]\d{5}):", re.MULTILINE
-    )
+    req_pattern = re.compile(r"^#{1,6}\s+REQ-(?:[A-Z]{2,4}-)?([pod]\d{5}):", re.MULTILINE)
 
     try:
         # Get list of spec files in committed state
@@ -246,9 +242,7 @@ def get_current_req_locations(
         exclude_files = ["INDEX.md", "README.md", "requirements-format.md"]
 
     req_locations: Dict[str, str] = {}
-    req_pattern = re.compile(
-        r"^#{1,6}\s+REQ-(?:[A-Z]{2,4}-)?([pod]\d{5}):", re.MULTILINE
-    )
+    req_pattern = re.compile(r"^#{1,6}\s+REQ-(?:[A-Z]{2,4}-)?([pod]\d{5}):", re.MULTILINE)
 
     spec_path = repo_root / spec_dir
     if not spec_path.exists():
@@ -266,7 +260,7 @@ def get_current_req_locations(
                 req_id = match.group(1)
                 req_locations[req_id] = rel_path
 
-        except (IOError, UnicodeDecodeError):
+        except (OSError, UnicodeDecodeError):
             continue
 
     return req_locations

elspais/core/parser.py

@@ -20,46 +20,39 @@ class RequirementParser:
     # Regex patterns for parsing
     # Generic pattern to find potential requirement headers
     # Actual ID validation is done by PatternValidator
-    HEADER_PATTERN = re.compile(
-        r"^#*\s*(?P<id>[A-Z]+-[A-Za-z0-9-]+):\s*(?P<title>.+)$"
-    )
+    HEADER_PATTERN = re.compile(r"^#*\s*(?P<id>[A-Z]+-[A-Za-z0-9-]+):\s*(?P<title>.+)$")
     LEVEL_STATUS_PATTERN = re.compile(
         r"\*\*Level\*\*:\s*(?P<level>\w+)"
         r"(?:\s*\|\s*\*\*Implements\*\*:\s*(?P<implements>[^|\n]+))?"
         r"(?:\s*\|\s*\*\*Status\*\*:\s*(?P<status>\w+))?"
     )
-    ALT_STATUS_PATTERN = re.compile(
-        r"\*\*Status\*\*:\s*(?P<status>\w+)"
-    )
-    IMPLEMENTS_PATTERN = re.compile(
-        r"\*\*Implements\*\*:\s*(?P<implements>[^|\n]+)"
-    )
+    ALT_STATUS_PATTERN = re.compile(r"\*\*Status\*\*:\s*(?P<status>\w+)")
+    IMPLEMENTS_PATTERN = re.compile(r"\*\*Implements\*\*:\s*(?P<implements>[^|\n]+)")
     END_MARKER_PATTERN = re.compile(
-        r"^\*End\*\s+\*[^*]+\*\s*(?:\|\s*\*\*Hash\*\*:\s*(?P<hash>[a-zA-Z0-9]+))?",
-        re.MULTILINE
-    )
-    RATIONALE_PATTERN = re.compile(
-        r"\*\*Rationale\*\*:\s*(.+?)(?=\n\n|\n\*\*|\Z)", re.DOTALL
+        r"^\*End\*\s+\*[^*]+\*\s*(?:\|\s*\*\*Hash\*\*:\s*(?P<hash>[a-zA-Z0-9]+))?", re.MULTILINE
     )
+    RATIONALE_PATTERN = re.compile(r"\*\*Rationale\*\*:\s*(.+?)(?=\n\n|\n\*\*|\Z)", re.DOTALL)
     ACCEPTANCE_PATTERN = re.compile(
         r"\*\*Acceptance Criteria\*\*:\s*\n((?:\s*-\s*.+\n?)+)", re.MULTILINE
     )
     # Assertions section header (## Assertions or **Assertions**)
-    ASSERTIONS_HEADER_PATTERN = re.compile(
-        r"^##\s+Assertions\s*$", re.MULTILINE
-    )
+    ASSERTIONS_HEADER_PATTERN = re.compile(r"^##\s+Assertions\s*$", re.MULTILINE)
     # Individual assertion line: "A. The system SHALL..." or "01. ..." etc.
     # Captures: label (any alphanumeric), text (rest of line, may continue)
-    ASSERTION_LINE_PATTERN = re.compile(
-        r"^\s*([A-Z0-9]+)\.\s+(.+)$", re.MULTILINE
-    )
+    ASSERTION_LINE_PATTERN = re.compile(r"^\s*([A-Z0-9]+)\.\s+(.+)$", re.MULTILINE)
 
     # Default values that mean "no references" in Implements field
     DEFAULT_NO_REFERENCE_VALUES = ["-", "null", "none", "x", "X", "N/A", "n/a"]
 
     # Default placeholder values that indicate a removed/deprecated assertion
     DEFAULT_PLACEHOLDER_VALUES = [
-        "obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"
+        "obsolete",
+        "removed",
+        "deprecated",
+        "N/A",
+        "n/a",
+        "-",
+        "reserved",
     ]
 
     def __init__(
@@ -272,9 +265,7 @@ class RequirementParser:
             else:
                 dir_path = base_path / dir_entry
             if dir_path.exists() and dir_path.is_dir():
-                result = self.parse_directory(
-                    dir_path, patterns=patterns, skip_files=skip_files
-                )
+                result = self.parse_directory(dir_path, patterns=patterns, skip_files=skip_files)
                 # Merge requirements, checking for cross-directory duplicates
                 for req_id, req in result.requirements.items():
                     if req_id in requirements:
@@ -385,7 +376,10 @@ class RequirementParser:
 
         warning = ParseWarning(
             requirement_id=original_id,
-            message=f"Duplicate ID found (first occurrence in {original_req.file_path}:{original_req.line_number})",
+            message=(
+                f"Duplicate ID found "
+                f"(first occurrence in {original_req.file_path}:{original_req.line_number})"
+            ),
             file_path=file_path,
             line_number=line_number,
         )
@@ -444,12 +438,14 @@ class RequirementParser:
         implements = self._parse_implements(implements_str)
         for ref in implements:
             if not self.validator.is_valid(ref):
-                block_warnings.append(ParseWarning(
-                    requirement_id=req_id,
-                    message=f"Invalid implements reference: {ref}",
-                    file_path=file_path,
-                    line_number=line_number,
-                ))
+                block_warnings.append(
+                    ParseWarning(
+                        requirement_id=req_id,
+                        message=f"Invalid implements reference: {ref}",
+                        file_path=file_path,
+                        line_number=line_number,
+                    )
+                )
 
         # Extract body (text between header and acceptance/end)
         body = self._extract_body(text)
@@ -475,12 +471,14 @@ class RequirementParser:
         assertions = self._extract_assertions(text)
         for assertion in assertions:
             if not self._is_valid_assertion_label(assertion.label):
-                block_warnings.append(ParseWarning(
-                    requirement_id=req_id,
-                    message=f"Invalid assertion label format: {assertion.label}",
-                    file_path=file_path,
-                    line_number=line_number,
-                ))
+                block_warnings.append(
+                    ParseWarning(
+                        requirement_id=req_id,
+                        message=f"Invalid assertion label format: {assertion.label}",
+                        file_path=file_path,
+                        line_number=line_number,
+                    )
+                )
 
         # Extract hash from end marker
         hash_value = None
@@ -511,17 +509,17 @@ class RequirementParser:
         Default expectation is uppercase letters A-Z.
         """
         # Check against configured assertion label pattern if available
-        assertion_config = getattr(self.pattern_config, 'assertions', None)
+        assertion_config = getattr(self.pattern_config, "assertions", None)
         if assertion_config:
-            label_style = assertion_config.get('label_style', 'uppercase')
-            if label_style == 'uppercase':
-                return bool(re.match(r'^[A-Z]$', label))
-            elif label_style == 'numeric':
-                return bool(re.match(r'^\d+$', label))
-            elif label_style == 'alphanumeric':
-                return bool(re.match(r'^[A-Z0-9]+$', label))
+            label_style = assertion_config.get("label_style", "uppercase")
+            if label_style == "uppercase":
+                return bool(re.match(r"^[A-Z]$", label))
+            elif label_style == "numeric":
+                return bool(re.match(r"^\d+$", label))
+            elif label_style == "alphanumeric":
+                return bool(re.match(r"^[A-Z0-9]+$", label))
         # Default: uppercase single letter
-        return bool(re.match(r'^[A-Z]$', label))
+        return bool(re.match(r"^[A-Z]$", label))
 
     def _parse_implements(self, implements_str: str) -> List[str]:
         """Parse comma-separated implements list.
@@ -608,9 +606,9 @@ class RequirementParser:
 
         # Find the end of the assertions section (next ## header, Rationale, or End marker)
         end_patterns = [
-            r"^##\s+",           # Next section header
-            r"^\*End\*",         # End marker
-            r"^---\s*$",         # Separator line
+            r"^##\s+",  # Next section header
+            r"^\*End\*",  # End marker
+            r"^---\s*$",  # Separator line
         ]
         end_pos = len(section_text)
         for pattern in end_patterns:
@@ -627,14 +625,15 @@ class RequirementParser:
 
             # Check if this is a placeholder
             is_placeholder = any(
-                assertion_text.lower().startswith(pv.lower())
-                for pv in self.placeholder_values
+                assertion_text.lower().startswith(pv.lower()) for pv in self.placeholder_values
             )
 
-            assertions.append(Assertion(
-                label=label,
-                text=assertion_text,
-                is_placeholder=is_placeholder,
-            ))
+            assertions.append(
+                Assertion(
+                    label=label,
+                    text=assertion_text,
+                    is_placeholder=is_placeholder,
+                )
+            )
 
         return assertions