elspais 0.9.1__py3-none-any.whl → 0.11.0__py3-none-any.whl

elspais/reformat/__init__.py

@@ -0,0 +1,50 @@
+# Implements: REQ-int-d00008 (Reformat Command)
+"""
+elspais.reformat - Requirement format transformation.
+
+Transforms legacy Acceptance Criteria format to Assertions format.
+Also provides line break normalization.
+
+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.hierarchy import (
+    RequirementNode,
+    get_all_requirements,
+    build_hierarchy,
+    traverse_top_down,
+    normalize_req_id,
+)
+
+__all__ = [
+    # Detection
+    "detect_format",
+    "needs_reformatting",
+    "FormatAnalysis",
+    # Transformation
+    "reformat_requirement",
+    "assemble_new_format",
+    "validate_reformatted_content",
+    # Line breaks
+    "normalize_line_breaks",
+    "fix_requirement_line_breaks",
+    "detect_line_break_issues",
+    # Hierarchy
+    "RequirementNode",
+    "get_all_requirements",
+    "build_hierarchy",
+    "traverse_top_down",
+    "normalize_req_id",
+]

elspais/reformat/detector.py

@@ -0,0 +1,119 @@
+# Implements: REQ-int-d00008 (Reformat Command)
+"""
+Format detection for requirements.
+
+Detects whether a requirement is in old format (needs reformatting)
+or new format (already reformatted).
+"""
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class FormatAnalysis:
+    """Result of format detection analysis."""
+    is_new_format: bool
+    has_assertions_section: bool
+    has_labeled_assertions: bool
+    has_acceptance_criteria: bool
+    uses_shall_language: bool
+    assertion_count: int
+    confidence: float  # 0.0 to 1.0
+
+
+def detect_format(body: str, rationale: str = "") -> FormatAnalysis:
+    """
+    Detect whether a requirement is in old or new format.
+
+    New format indicators:
+    - Has '## Assertions' section with labeled assertions (A., B., C.)
+    - Does NOT have '**Acceptance Criteria**:' section
+    - Uses prescriptive SHALL language in assertions
+
+    Old format indicators:
+    - Has '**Acceptance Criteria**:' or 'Acceptance Criteria:' section
+    - Uses descriptive language (does, has, provides) without labeled assertions
+    - May have bullet points without letter labels
+
+    Args:
+        body: The requirement body text
+        rationale: Optional rationale text
+
+    Returns:
+        FormatAnalysis with detection results
+    """
+    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)
+    )
+
+    # 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
+    )
+    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
+    ))
+
+    # Check for SHALL language usage anywhere
+    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
+    )
+
+    # Calculate confidence score
+    confidence = 0.0
+    if has_assertions_section:
+        confidence += 0.35
+    if has_labeled_assertions:
+        confidence += 0.35
+    if not has_acceptance_criteria:
+        confidence += 0.20
+    if uses_shall_language:
+        confidence += 0.10
+
+    # Invert confidence if old format
+    if not is_new_format:
+        confidence = 1.0 - confidence
+
+    return FormatAnalysis(
+        is_new_format=is_new_format,
+        has_assertions_section=has_assertions_section,
+        has_labeled_assertions=has_labeled_assertions,
+        has_acceptance_criteria=has_acceptance_criteria,
+        uses_shall_language=uses_shall_language,
+        assertion_count=assertion_count,
+        confidence=confidence
+    )
+
+
+def needs_reformatting(body: str, rationale: str = "") -> bool:
+    """
+    Simple check if a requirement needs reformatting.
+
+    Args:
+        body: The requirement body text
+        rationale: Optional rationale text
+
+    Returns:
+        True if the requirement needs reformatting (is in old format)
+    """
+    analysis = detect_format(body, rationale)
+    return not analysis.is_new_format

elspais/reformat/hierarchy.py

@@ -0,0 +1,246 @@
+# Implements: REQ-int-d00008 (Reformat Command)
+"""
+Hierarchy traversal logic for requirements.
+
+Uses elspais core modules directly to parse requirements and build
+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
+
+if TYPE_CHECKING:
+    from elspais.core.models import Requirement
+    from elspais.core.patterns import PatternValidator
+
+
+@dataclass
+class RequirementNode:
+    """Represents a requirement with its metadata and hierarchy info."""
+    req_id: str
+    title: str
+    body: str
+    rationale: str
+    file_path: str
+    line: int
+    implements: List[str]  # Parent REQ IDs
+    hash: str
+    status: str
+    level: str
+    children: List[str] = field(default_factory=list)  # Child REQ IDs
+
+    @classmethod
+    def from_core(cls, req: "Requirement") -> "RequirementNode":
+        """
+        Create a RequirementNode from a core Requirement object.
+
+        Args:
+            req: Core Requirement object from elspais.core.models
+
+        Returns:
+            RequirementNode with mapped fields
+        """
+        return cls(
+            req_id=req.id,
+            title=req.title,
+            body=req.body,
+            rationale=req.rationale or "",
+            file_path=str(req.file_path) if req.file_path else "",
+            line=req.line_number or 0,
+            implements=list(req.implements),
+            hash=req.hash or "",
+            status=req.status,
+            level=req.level,
+            children=[],
+        )
+
+
+def get_all_requirements(
+    config_path: Optional[Path] = None,
+    base_path: Optional[Path] = None,
+    mode: str = "combined",
+) -> Dict[str, RequirementNode]:
+    """
+    Get all requirements using core parser directly.
+
+    Args:
+        config_path: Optional path to .elspais.toml config file
+        base_path: Base path for resolving relative directories
+        mode: Which repos to include:
+            - "combined" (default): Load local + core/associated repo requirements
+            - "core-only": Load only core/associated repo requirements
+            - "local-only": Load only local 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.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:
+        config_path = find_config_file(base_path or Path.cwd())
+
+    if config_path is None:
+        print("Warning: No .elspais.toml found", file=sys.stderr)
+        return {}
+
+    try:
+        config = load_config(config_path)
+    except Exception as e:
+        print(f"Warning: Failed to load config: {e}", file=sys.stderr)
+        return {}
+
+    requirements = {}
+
+    # Load local requirements (unless core-only mode)
+    if mode in ("combined", "local-only"):
+        # Create parser with pattern config
+        pattern_config = PatternConfig.from_dict(config.get("patterns", {}))
+        parser = RequirementParser(pattern_config)
+
+        # Get spec directories
+        spec_dirs = get_spec_directories(None, config, base_path or config_path.parent)
+
+        if spec_dirs:
+            try:
+                parse_result = parser.parse_directories(spec_dirs)
+                for req_id, req in parse_result.requirements.items():
+                    requirements[req_id] = RequirementNode.from_core(req)
+            except Exception as e:
+                print(f"Warning: Failed to parse local requirements: {e}", file=sys.stderr)
+
+    # Load core/associated repo requirements (unless local-only mode)
+    if mode in ("combined", "core-only"):
+        core_path = config.get("core", {}).get("path")
+        if core_path:
+            core_reqs = load_requirements_from_repo(Path(core_path), config)
+            for req_id, req in core_reqs.items():
+                # Don't overwrite local requirements with same ID
+                if req_id not in requirements:
+                    requirements[req_id] = RequirementNode.from_core(req)
+
+    if not requirements:
+        print("Warning: No requirements found", file=sys.stderr)
+
+    return requirements
+
+
+def build_hierarchy(requirements: Dict[str, RequirementNode]) -> Dict[str, RequirementNode]:
+    """
+    Compute children for each requirement by inverting implements relationships.
+
+    This modifies the requirements dict in-place, populating each node's
+    children list.
+    """
+    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}"
+            if parent_key in requirements:
+                requirements[parent_key].children.append(req_id)
+
+    # Sort children for deterministic traversal
+    for node in requirements.values():
+        node.children.sort()
+
+    return requirements
+
+
+def traverse_top_down(
+    requirements: Dict[str, RequirementNode],
+    start_req: str,
+    max_depth: Optional[int] = None,
+    callback: Optional[Callable[[RequirementNode, int], None]] = None
+) -> List[str]:
+    """
+    Traverse hierarchy from start_req downward using BFS.
+
+    Args:
+        requirements: All requirements with children computed
+        start_req: Starting REQ ID (e.g., 'REQ-p00044')
+        max_depth: Maximum depth to traverse (None = unlimited)
+        callback: Function to call for each REQ visited (node, depth)
+
+    Returns:
+        List of REQ IDs in traversal order
+    """
+    visited = []
+    queue = [(start_req, 0)]  # (req_id, depth)
+    seen = set()
+
+    while queue:
+        req_id, depth = queue.pop(0)
+
+        if req_id in seen:
+            continue
+
+        # Depth limit check (depth 0 is the start node)
+        if max_depth is not None and depth > max_depth:
+            continue
+
+        seen.add(req_id)
+
+        if req_id not in requirements:
+            print(f"Warning: {req_id} not found in requirements", file=sys.stderr)
+            continue
+
+        visited.append(req_id)
+        node = requirements[req_id]
+
+        if callback:
+            callback(node, depth)
+
+        # Add children to queue
+        for child_id in node.children:
+            if child_id not in seen:
+                queue.append((child_id, depth + 1))
+
+    return visited
+
+
+def normalize_req_id(req_id: str, validator: Optional["PatternValidator"] = None) -> str:
+    """
+    Normalize requirement ID to canonical format using PatternValidator.
+
+    Args:
+        req_id: Requirement ID (e.g., "d00027", "REQ-d00027", "REQ-CAL-p00001")
+        validator: PatternValidator instance (created from config if not provided)
+
+    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
+
+    # Create validator if not provided
+    if validator is None:
+        try:
+            config_path = find_config_file(Path.cwd())
+            config = load_config(config_path) if config_path else {}
+        except Exception:
+            config = {}
+        pattern_config = PatternConfig.from_dict(config.get("patterns", {}))
+        validator = PatternValidator(pattern_config)
+
+    # Try parsing the ID as-is
+    parsed = validator.parse(req_id)
+
+    # If that fails, try with prefix
+    if parsed is None and not req_id.upper().startswith(validator.config.prefix):
+        parsed = validator.parse(f"{validator.config.prefix}-{req_id}")
+
+    if parsed:
+        # Reconstruct canonical ID from parsed components
+        parts = [parsed.prefix]
+        if parsed.associated:
+            parts.append(parsed.associated)
+        parts.append(f"{parsed.type_code}{parsed.number}")
+        return "-".join(parts)
+
+    # Return as-is if unparseable
+    return req_id

elspais/reformat/line_breaks.py

@@ -0,0 +1,220 @@
+# Implements: REQ-int-d00008-C (Line break normalization)
+"""
+Line break normalization for requirement content.
+
+Provides functions to:
+- Remove unnecessary blank lines after section headers
+- Reflow paragraphs (join lines broken mid-sentence)
+- Preserve intentional structure (list items, code blocks)
+
+IMPLEMENTS REQUIREMENTS:
+    REQ-int-d00008-C: Line break normalization SHALL be included.
+"""
+
+import re
+from typing import List, Tuple
+
+
+def normalize_line_breaks(content: str, reflow: bool = True) -> str:
+    """
+    Normalize line breaks in requirement content.
+
+    Args:
+        content: Raw requirement markdown content
+        reflow: If True, also reflow paragraphs (join broken lines)
+
+    Returns:
+        Content with normalized line breaks
+    """
+    lines = content.split('\n')
+    result_lines: List[str] = []
+
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+
+        # Check if this is a section header (## Something)
+        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() == '':
+                i += 1
+            # Add single blank line after header for readability
+            result_lines.append('')
+            continue
+
+        # Check if this starts a paragraph that might need reflowing
+        if reflow and line.strip() and not _is_structural_line(line):
+            # Collect paragraph lines
+            para_lines = [line.rstrip()]
+            i += 1
+            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)):
+                    break
+                para_lines.append(next_line.rstrip())
+                i += 1
+
+            # Join and reflow the paragraph
+            reflowed = _reflow_paragraph(para_lines)
+            result_lines.append(reflowed)
+            continue
+
+        # Keep structural lines and blank lines as-is
+        result_lines.append(line.rstrip())
+        i += 1
+
+    # Clean up multiple consecutive blank lines
+    return _collapse_blank_lines('\n'.join(result_lines))
+
+
+def _is_structural_line(line: str) -> bool:
+    """
+    Check if a line is structural (should not be reflowed).
+
+    Structural lines include:
+    - List items (A., B., 1., -, *)
+    - Headers (# or ##)
+    - Metadata lines (**Level**: etc)
+    - End markers (*End* ...)
+    - Code fence markers (```)
+    """
+    stripped = line.strip()
+
+    if not stripped:
+        return False
+
+    # Headers
+    if stripped.startswith('#'):
+        return True
+
+    # Lettered assertions (A. B. C. etc)
+    if re.match(r'^[A-Z]\.\s', stripped):
+        return True
+
+    # Numbered lists (1. 2. 3. etc)
+    if re.match(r'^\d+\.\s', stripped):
+        return True
+
+    # Bullet points
+    if stripped.startswith(('- ', '* ', '+ ')):
+        return True
+
+    # Metadata line
+    if stripped.startswith('**Level**:') or stripped.startswith('**Status**:'):
+        return True
+
+    # Combined metadata line
+    if re.match(r'\*\*Level\*\*:', stripped):
+        return True
+
+    # End marker
+    if stripped.startswith('*End*'):
+        return True
+
+    # Code fence
+    if stripped.startswith('```'):
+        return True
+
+    return False
+
+
+def _reflow_paragraph(lines: List[str]) -> str:
+    """
+    Reflow a list of paragraph lines into a single line.
+
+    Args:
+        lines: Lines that form a paragraph
+
+    Returns:
+        Single reflowed line
+    """
+    if not lines:
+        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())
+    # Collapse multiple spaces
+    return re.sub(r'\s+', ' ', joined)
+
+
+def _collapse_blank_lines(content: str) -> str:
+    """
+    Collapse multiple consecutive blank lines into single blank lines.
+
+    Args:
+        content: Content that may have multiple blank lines
+
+    Returns:
+        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)
+
+
+def fix_requirement_line_breaks(
+    body: str,
+    rationale: str,
+    reflow: bool = True
+) -> Tuple[str, str]:
+    """
+    Fix line breaks in requirement body and rationale.
+
+    Args:
+        body: Requirement body text
+        rationale: Requirement rationale text
+        reflow: Whether to reflow paragraphs
+
+    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 ''
+
+    return fixed_body, fixed_rationale
+
+
+def detect_line_break_issues(content: str) -> List[str]:
+    """
+    Detect potential line break issues in content.
+
+    Returns list of issues found for reporting.
+    """
+    issues = []
+    lines = content.split('\n')
+
+    for i, line in enumerate(lines):
+        # Check for blank line after section header
+        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() == '':
+                blank_count += 1
+                j += 1
+            if blank_count > 1:
+                issues.append(
+                    f"Line {i+1}: Multiple blank lines ({blank_count}) after section header"
+                )
+
+        # 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])):
+            # 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"
+                )
+
+    return issues