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

elspais/core/patterns.py

@@ -116,9 +116,7 @@ class PatternValidator:
         self.config = config
         self._regex = self._build_regex()
         self._regex_with_assertion = self._build_regex(include_assertion=True)
-        self._assertion_label_regex = re.compile(
-            f"^{self.config.get_assertion_label_pattern()}$"
-        )
+        self._assertion_label_regex = re.compile(f"^{self.config.get_assertion_label_pattern()}$")
 
     def _build_regex(self, include_assertion: bool = False) -> re.Pattern:
         """Build regex pattern from configuration.
@@ -306,9 +304,7 @@ class PatternValidator:
 
         raise ValueError(f"Cannot parse assertion label: {label}")
 
-    def format(
-        self, type_code: str, number: int, associated: Optional[str] = None
-    ) -> str:
+    def format(self, type_code: str, number: int, associated: Optional[str] = None) -> str:
         """
         Format a requirement ID from components.
 

elspais/core/rules.py

@@ -101,9 +101,9 @@ class FormatConfig:
     require_shall: bool = True
     labels_sequential: bool = True
     labels_unique: bool = True
-    placeholder_values: List[str] = field(default_factory=lambda: [
-        "obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"
-    ])
+    placeholder_values: List[str] = field(
+        default_factory=lambda: ["obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"]
+    )
 
 
 @dataclass
@@ -142,9 +142,10 @@ class RulesConfig:
             require_shall=format_data.get("require_shall", True),
             labels_sequential=format_data.get("labels_sequential", True),
             labels_unique=format_data.get("labels_unique", True),
-            placeholder_values=format_data.get("placeholder_values", [
-                "obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"
-            ]),
+            placeholder_values=format_data.get(
+                "placeholder_values",
+                ["obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"],
+            ),
         )
 
         return cls(hierarchy=hierarchy, format=format_config)
@@ -169,9 +170,7 @@ class RuleEngine:
         """
         self.config = config
         self.pattern_config = pattern_config
-        self.pattern_validator = (
-            PatternValidator(pattern_config) if pattern_config else None
-        )
+        self.pattern_validator = PatternValidator(pattern_config) if pattern_config else None
 
     def validate(self, requirements: Dict[str, Requirement]) -> List[RuleViolation]:
         """
@@ -381,9 +380,7 @@ class RuleEngine:
 
         return violations
 
-    def _check_assertions(
-        self, req_id: str, req: Requirement
-    ) -> List[RuleViolation]:
+    def _check_assertions(self, req_id: str, req: Requirement) -> List[RuleViolation]:
         """Check assertion-specific validation rules."""
         violations = []
 
@@ -426,9 +423,7 @@ class RuleEngine:
         if self.config.format.labels_sequential and self.pattern_validator:
             expected_labels = []
             for i in range(len(labels)):
-                expected_labels.append(
-                    self.pattern_validator.format_assertion_label(i)
-                )
+                expected_labels.append(self.pattern_validator.format_assertion_label(i))
             if labels != expected_labels:
                 msg = f"Labels not sequential: {labels} (expected {expected_labels})"
                 violations.append(

elspais/mcp/__init__.py

@@ -33,10 +33,12 @@ __all__ = [
 def create_server(working_dir=None):
     """Create MCP server instance."""
     from elspais.mcp.server import create_server as _create
+
     return _create(working_dir)
 
 
 def run_server(working_dir=None, transport="stdio"):
     """Run MCP server."""
     from elspais.mcp.server import run_server as _run
+
     return _run(working_dir, transport)

elspais/mcp/context.py

@@ -52,6 +52,7 @@ class WorkspaceContext:
         else:
             # Use defaults
             from elspais.config.defaults import DEFAULT_CONFIG
+
             config = DEFAULT_CONFIG.copy()
 
         return cls(working_dir=directory, config=config)

elspais/mcp/serializers.py

@@ -4,7 +4,7 @@ elspais.mcp.serializers - JSON serialization for MCP responses.
 Provides functions to serialize elspais data models to JSON-compatible dicts.
 """
 
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 from elspais.core.models import Assertion, ContentRule, Requirement
 from elspais.core.rules import RuleViolation

elspais/mcp/server.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Optional
 
 try:
     from mcp.server.fastmcp import FastMCP
+
     MCP_AVAILABLE = True
 except ImportError:
     MCP_AVAILABLE = False
@@ -39,8 +40,7 @@ def create_server(working_dir: Optional[Path] = None) -> "FastMCP":
     """
     if not MCP_AVAILABLE:
         raise ImportError(
-            "MCP dependencies not installed. "
-            "Install with: pip install elspais[mcp]"
+            "MCP dependencies not installed. " "Install with: pip install elspais[mcp]"
         )
 
     if working_dir is None:
@@ -75,14 +75,17 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         ID, title, level, status, and assertion count.
         """
         import json
+
         requirements = ctx.get_requirements()
-        return json.dumps({
-            "count": len(requirements),
-            "requirements": [
-                serialize_requirement_summary(req)
-                for req in requirements.values()
-            ]
-        }, indent=2)
+        return json.dumps(
+            {
+                "count": len(requirements),
+                "requirements": [
+                    serialize_requirement_summary(req) for req in requirements.values()
+                ],
+            },
+            indent=2,
+        )
 
     @mcp.resource("requirements://{req_id}")
     def get_requirement_resource(req_id: str) -> str:
@@ -93,6 +96,7 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         implements references, and location.
         """
         import json
+
         req = ctx.get_requirement(req_id)
         if req is None:
             return json.dumps({"error": f"Requirement {req_id} not found"})
@@ -102,34 +106,39 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
     def get_requirements_by_level(level: str) -> str:
         """Get all requirements of a specific level (PRD, OPS, DEV)."""
         import json
+
         requirements = ctx.get_requirements()
-        filtered = [
-            r for r in requirements.values()
-            if r.level.upper() == level.upper()
-        ]
-        return json.dumps({
-            "level": level,
-            "count": len(filtered),
-            "requirements": [serialize_requirement_summary(r) for r in filtered]
-        }, indent=2)
+        filtered = [r for r in requirements.values() if r.level.upper() == level.upper()]
+        return json.dumps(
+            {
+                "level": level,
+                "count": len(filtered),
+                "requirements": [serialize_requirement_summary(r) for r in filtered],
+            },
+            indent=2,
+        )
 
     @mcp.resource("content-rules://list")
     def list_content_rules() -> str:
         """List all configured content rule files."""
         import json
+
         rules = ctx.get_content_rules()
-        return json.dumps({
-            "count": len(rules),
-            "rules": [
-                {
-                    "file": str(r.file_path),
-                    "title": r.title,
-                    "type": r.type,
-                    "applies_to": r.applies_to,
-                }
-                for r in rules
-            ]
-        }, indent=2)
+        return json.dumps(
+            {
+                "count": len(rules),
+                "rules": [
+                    {
+                        "file": str(r.file_path),
+                        "title": r.title,
+                        "type": r.type,
+                        "applies_to": r.applies_to,
+                    }
+                    for r in rules
+                ],
+            },
+            indent=2,
+        )
 
     @mcp.resource("content-rules://{filename}")
     def get_content_rule(filename: str) -> str:
@@ -140,6 +149,7 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         requirement formats and authoring guidelines.
         """
         import json
+
         rules = ctx.get_content_rules()
         for rule in rules:
             if rule.file_path.name == filename or str(rule.file_path).endswith(filename):
@@ -150,6 +160,7 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
     def get_current_config() -> str:
         """Get the current elspais configuration."""
         import json
+
         return json.dumps(ctx.config, indent=2, default=str)
 
 
@@ -186,7 +197,10 @@ def _register_tools(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
             "valid": len(errors) == 0,
             "errors": [serialize_violation(v) for v in errors],
             "warnings": [serialize_violation(v) for v in warnings],
-            "summary": f"{len(errors)} errors, {len(warnings)} warnings in {len(requirements)} requirements"
+            "summary": (
+                f"{len(errors)} errors, {len(warnings)} warnings "
+                f"in {len(requirements)} requirements"
+            ),
         }
 
     @mcp.tool()
@@ -209,9 +223,8 @@ def _register_tools(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         return {
             "count": len(requirements),
             "requirements": {
-                req_id: serialize_requirement(req)
-                for req_id, req in requirements.items()
-            }
+                req_id: serialize_requirement(req) for req_id, req in requirements.items()
+            },
         }
 
     @mcp.tool()
@@ -233,7 +246,7 @@ def _register_tools(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
             "count": len(results),
             "query": query,
             "field": field,
-            "requirements": [serialize_requirement_summary(r) for r in results]
+            "requirements": [serialize_requirement_summary(r) for r in results],
         }
 
     @mcp.tool()
@@ -299,10 +312,12 @@ def _analyze_orphans(requirements: Dict[str, Any]) -> Dict[str, Any]:
     for req in requirements.values():
         for parent_id in req.implements:
             if parent_id not in all_ids:
-                orphans.append({
-                    "id": req.id,
-                    "missing_parent": parent_id,
-                })
+                orphans.append(
+                    {
+                        "id": req.id,
+                        "missing_parent": parent_id,
+                    }
+                )
 
     return {
         "count": len(orphans),

elspais/reformat/__init__.py

@@ -9,23 +9,23 @@ IMPLEMENTS REQUIREMENTS:
     REQ-int-d00008: Reformat Command
 """
 
-from elspais.reformat.detector import detect_format, needs_reformatting, FormatAnalysis
-from elspais.reformat.transformer import (
-    reformat_requirement,
-    assemble_new_format,
-    validate_reformatted_content,
-)
-from elspais.reformat.line_breaks import (
-    normalize_line_breaks,
-    fix_requirement_line_breaks,
-    detect_line_break_issues,
-)
+from elspais.reformat.detector import FormatAnalysis, detect_format, needs_reformatting
 from elspais.reformat.hierarchy import (
     RequirementNode,
-    get_all_requirements,
     build_hierarchy,
-    traverse_top_down,
+    get_all_requirements,
     normalize_req_id,
+    traverse_top_down,
+)
+from elspais.reformat.line_breaks import (
+    detect_line_break_issues,
+    fix_requirement_line_breaks,
+    normalize_line_breaks,
+)
+from elspais.reformat.transformer import (
+    assemble_new_format,
+    reformat_requirement,
+    validate_reformatted_content,
 )
 
 __all__ = [

elspais/reformat/detector.py

@@ -13,6 +13,7 @@ from dataclasses import dataclass
 @dataclass
 class FormatAnalysis:
     """Result of format detection analysis."""
+
     is_new_format: bool
     has_assertions_section: bool
     has_labeled_assertions: bool
@@ -46,36 +47,28 @@ def detect_format(body: str, rationale: str = "") -> FormatAnalysis:
     full_text = f"{body}\n{rationale}".strip()
 
     # Check for ## Assertions section
-    has_assertions_section = bool(
-        re.search(r'^##\s+Assertions\s*$', full_text, re.MULTILINE)
-    )
+    has_assertions_section = bool(re.search(r"^##\s+Assertions\s*$", full_text, re.MULTILINE))
 
     # Check for labeled assertions (A., B., C., etc. followed by SHALL somewhere in the line)
     labeled_assertions = re.findall(
-        r'^[A-Z]\.\s+.*\bSHALL\b',
-        full_text,
-        re.MULTILINE | re.IGNORECASE
+        r"^[A-Z]\.\s+.*\bSHALL\b", full_text, re.MULTILINE | re.IGNORECASE
     )
     has_labeled_assertions = len(labeled_assertions) >= 1
     assertion_count = len(labeled_assertions)
 
     # Check for Acceptance Criteria section
-    has_acceptance_criteria = bool(re.search(
-        r'\*?\*?Acceptance\s+Criteria\*?\*?\s*:',
-        full_text,
-        re.IGNORECASE
-    ))
+    has_acceptance_criteria = bool(
+        re.search(r"\*?\*?Acceptance\s+Criteria\*?\*?\s*:", full_text, re.IGNORECASE)
+    )
 
     # Check for SHALL language usage anywhere
-    shall_count = len(re.findall(r'\bSHALL\b', full_text, re.IGNORECASE))
+    shall_count = len(re.findall(r"\bSHALL\b", full_text, re.IGNORECASE))
     uses_shall_language = shall_count >= 1
 
     # Determine if new format
     # New format: has Assertions section with labeled assertions, no Acceptance Criteria
     is_new_format = (
-        has_assertions_section and
-        has_labeled_assertions and
-        not has_acceptance_criteria
+        has_assertions_section and has_labeled_assertions and not has_acceptance_criteria
     )
 
     # Calculate confidence score
@@ -100,7 +93,7 @@ def detect_format(body: str, rationale: str = "") -> FormatAnalysis:
         has_acceptance_criteria=has_acceptance_criteria,
         uses_shall_language=uses_shall_language,
         assertion_count=assertion_count,
-        confidence=confidence
+        confidence=confidence,
     )
 
 

elspais/reformat/hierarchy.py

@@ -9,7 +9,7 @@ a traversable hierarchy based on implements relationships.
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Callable, Dict, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional
 
 if TYPE_CHECKING:
     from elspais.core.models import Requirement
@@ -19,6 +19,7 @@ if TYPE_CHECKING:
 @dataclass
 class RequirementNode:
     """Represents a requirement with its metadata and hierarchy info."""
+
     req_id: str
     title: str
     body: str
@@ -76,10 +77,10 @@ def get_all_requirements(
     Returns:
         Dict mapping requirement ID (e.g., 'REQ-d00027') to RequirementNode
     """
-    from elspais.config.loader import load_config, find_config_file, get_spec_directories
+    from elspais.commands.validate import load_requirements_from_repo
+    from elspais.config.loader import find_config_file, get_spec_directories, load_config
     from elspais.core.parser import RequirementParser
     from elspais.core.patterns import PatternConfig
-    from elspais.commands.validate import load_requirements_from_repo
 
     # Find and load config
     if config_path is None:
@@ -140,7 +141,7 @@ def build_hierarchy(requirements: Dict[str, RequirementNode]) -> Dict[str, Requi
     for req_id, node in requirements.items():
         for parent_id in node.implements:
             # Normalize parent ID format
-            parent_key = parent_id if parent_id.startswith('REQ-') else f"REQ-{parent_id}"
+            parent_key = parent_id if parent_id.startswith("REQ-") else f"REQ-{parent_id}"
             if parent_key in requirements:
                 requirements[parent_key].children.append(req_id)
 
@@ -155,7 +156,7 @@ def traverse_top_down(
     requirements: Dict[str, RequirementNode],
     start_req: str,
     max_depth: Optional[int] = None,
-    callback: Optional[Callable[[RequirementNode, int], None]] = None
+    callback: Optional[Callable[[RequirementNode, int], None]] = None,
 ) -> List[str]:
     """
     Traverse hierarchy from start_req downward using BFS.
@@ -214,8 +215,8 @@ def normalize_req_id(req_id: str, validator: Optional["PatternValidator"] = None
     Returns:
         Normalized ID in canonical format from config
     """
-    from elspais.config.loader import load_config, find_config_file
-    from elspais.core.patterns import PatternValidator, PatternConfig
+    from elspais.config.loader import find_config_file, load_config
+    from elspais.core.patterns import PatternConfig, PatternValidator
 
     # Create validator if not provided
     if validator is None:

elspais/reformat/line_breaks.py

@@ -26,7 +26,7 @@ def normalize_line_breaks(content: str, reflow: bool = True) -> str:
     Returns:
         Content with normalized line breaks
     """
-    lines = content.split('\n')
+    lines = content.split("\n")
     result_lines: List[str] = []
 
     i = 0
@@ -34,14 +34,14 @@ def normalize_line_breaks(content: str, reflow: bool = True) -> str:
         line = lines[i]
 
         # Check if this is a section header (## Something)
-        if re.match(r'^##\s+\w', line):
+        if re.match(r"^##\s+\w", line):
             result_lines.append(line)
             # Skip blank lines immediately after section header
             i += 1
-            while i < len(lines) and lines[i].strip() == '':
+            while i < len(lines) and lines[i].strip() == "":
                 i += 1
             # Add single blank line after header for readability
-            result_lines.append('')
+            result_lines.append("")
             continue
 
         # Check if this starts a paragraph that might need reflowing
@@ -52,9 +52,11 @@ def normalize_line_breaks(content: str, reflow: bool = True) -> str:
             while i < len(lines):
                 next_line = lines[i]
                 # Stop at blank lines, structural elements, or next section
-                if (next_line.strip() == '' or
-                    _is_structural_line(next_line) or
-                    re.match(r'^##\s+', next_line)):
+                if (
+                    next_line.strip() == ""
+                    or _is_structural_line(next_line)
+                    or re.match(r"^##\s+", next_line)
+                ):
                     break
                 para_lines.append(next_line.rstrip())
                 i += 1
@@ -69,7 +71,7 @@ def normalize_line_breaks(content: str, reflow: bool = True) -> str:
         i += 1
 
     # Clean up multiple consecutive blank lines
-    return _collapse_blank_lines('\n'.join(result_lines))
+    return _collapse_blank_lines("\n".join(result_lines))
 
 
 def _is_structural_line(line: str) -> bool:
@@ -89,35 +91,35 @@ def _is_structural_line(line: str) -> bool:
         return False
 
     # Headers
-    if stripped.startswith('#'):
+    if stripped.startswith("#"):
         return True
 
     # Lettered assertions (A. B. C. etc)
-    if re.match(r'^[A-Z]\.\s', stripped):
+    if re.match(r"^[A-Z]\.\s", stripped):
         return True
 
     # Numbered lists (1. 2. 3. etc)
-    if re.match(r'^\d+\.\s', stripped):
+    if re.match(r"^\d+\.\s", stripped):
         return True
 
     # Bullet points
-    if stripped.startswith(('- ', '* ', '+ ')):
+    if stripped.startswith(("- ", "* ", "+ ")):
         return True
 
     # Metadata line
-    if stripped.startswith('**Level**:') or stripped.startswith('**Status**:'):
+    if stripped.startswith("**Level**:") or stripped.startswith("**Status**:"):
         return True
 
     # Combined metadata line
-    if re.match(r'\*\*Level\*\*:', stripped):
+    if re.match(r"\*\*Level\*\*:", stripped):
         return True
 
     # End marker
-    if stripped.startswith('*End*'):
+    if stripped.startswith("*End*"):
         return True
 
     # Code fence
-    if stripped.startswith('```'):
+    if stripped.startswith("```"):
         return True
 
     return False
@@ -134,15 +136,15 @@ def _reflow_paragraph(lines: List[str]) -> str:
         Single reflowed line
     """
     if not lines:
-        return ''
+        return ""
 
     if len(lines) == 1:
         return lines[0]
 
     # Join lines with space, collapsing multiple spaces
-    joined = ' '.join(line.strip() for line in lines if line.strip())
+    joined = " ".join(line.strip() for line in lines if line.strip())
     # Collapse multiple spaces
-    return re.sub(r'\s+', ' ', joined)
+    return re.sub(r"\s+", " ", joined)
 
 
 def _collapse_blank_lines(content: str) -> str:
@@ -156,14 +158,10 @@ def _collapse_blank_lines(content: str) -> str:
         Content with at most one blank line between paragraphs
     """
     # Replace 3+ newlines with 2 newlines (one blank line)
-    return re.sub(r'\n{3,}', '\n\n', content)
+    return re.sub(r"\n{3,}", "\n\n", content)
 
 
-def fix_requirement_line_breaks(
-    body: str,
-    rationale: str,
-    reflow: bool = True
-) -> Tuple[str, str]:
+def fix_requirement_line_breaks(body: str, rationale: str, reflow: bool = True) -> Tuple[str, str]:
     """
     Fix line breaks in requirement body and rationale.
 
@@ -175,8 +173,8 @@ def fix_requirement_line_breaks(
     Returns:
         Tuple of (fixed_body, fixed_rationale)
     """
-    fixed_body = normalize_line_breaks(body, reflow=reflow) if body else ''
-    fixed_rationale = normalize_line_breaks(rationale, reflow=reflow) if rationale else ''
+    fixed_body = normalize_line_breaks(body, reflow=reflow) if body else ""
+    fixed_rationale = normalize_line_breaks(rationale, reflow=reflow) if rationale else ""
 
     return fixed_body, fixed_rationale
 
@@ -188,15 +186,15 @@ def detect_line_break_issues(content: str) -> List[str]:
     Returns list of issues found for reporting.
     """
     issues = []
-    lines = content.split('\n')
+    lines = content.split("\n")
 
     for i, line in enumerate(lines):
         # Check for blank line after section header
-        if re.match(r'^##\s+\w', line):
+        if re.match(r"^##\s+\w", line):
             # Look ahead for multiple blank lines
             blank_count = 0
             j = i + 1
-            while j < len(lines) and lines[j].strip() == '':
+            while j < len(lines) and lines[j].strip() == "":
                 blank_count += 1
                 j += 1
             if blank_count > 1:
@@ -206,15 +204,15 @@ def detect_line_break_issues(content: str) -> List[str]:
 
         # Check for mid-sentence line break (line ends without punctuation)
         stripped = line.rstrip()
-        if (stripped and
-            not _is_structural_line(line) and
-            i + 1 < len(lines) and
-            lines[i + 1].strip() and
-            not _is_structural_line(lines[i + 1])):
+        if (
+            stripped
+            and not _is_structural_line(line)
+            and i + 1 < len(lines)
+            and lines[i + 1].strip()
+            and not _is_structural_line(lines[i + 1])
+        ):
             # Line ends with a word (not punctuation), followed by non-empty line
             if stripped and stripped[-1].isalnum():
-                issues.append(
-                    f"Line {i+1}: Possible mid-sentence line break"
-                )
+                issues.append(f"Line {i+1}: Possible mid-sentence line break")
 
     return issues