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

elspais/commands/validate.py

@@ -17,6 +17,7 @@ from elspais.core.models import ParseWarning, Requirement
 from elspais.core.parser import RequirementParser
 from elspais.core.patterns import PatternConfig
 from elspais.core.rules import RuleEngine, RulesConfig, RuleViolation, Severity
+from elspais.sponsors import get_sponsor_spec_directories
 from elspais.testing.config import TestingConfig
 
 
@@ -41,6 +42,19 @@ def run(args: argparse.Namespace) -> int:
         print("Error: No spec directories found", file=sys.stderr)
         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)
+
+    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:
+            spec_dirs = list(spec_dirs) + sponsor_dirs
+            if not args.quiet:
+                for sponsor_dir in sponsor_dirs:
+                    print(f"Including sponsor specs: {sponsor_dir}")
+
     if not args.quiet:
         if len(spec_dirs) == 1:
             print(f"Validating requirements in: {spec_dirs[0]}")
@@ -245,8 +259,9 @@ def validate_links(
 
     # Load core requirements if this is an associated repo
     core_requirements = {}
-    if args.core_repo:
-        core_requirements = load_core_requirements(args.core_repo, config)
+    core_path = args.core_repo or config.get("core", {}).get("path")
+    if core_path:
+        core_requirements = load_requirements_from_repo(Path(core_path), config)
 
     all_requirements = {**core_requirements, **requirements}
     all_ids = set(all_requirements.keys())
@@ -311,24 +326,32 @@ def convert_parse_warnings_to_violations(
     return violations
 
 
-def load_core_requirements(core_path: Path, config: Dict) -> Dict[str, Requirement]:
-    """Load requirements from core repository."""
-    if not core_path.exists():
+def load_requirements_from_repo(repo_path: Path, config: Dict) -> Dict[str, Requirement]:
+    """Load requirements from any repository path.
+
+    Args:
+        repo_path: Path to the repository root
+        config: Configuration dict (used as fallback if repo has no config)
+
+    Returns:
+        Dict mapping requirement ID to Requirement object
+    """
+    if not repo_path.exists():
         return {}
 
-    # Find core config
-    core_config_path = core_path / ".elspais.toml"
-    if core_config_path.exists():
-        core_config = load_config(core_config_path)
+    # Find repo config
+    repo_config_path = repo_path / ".elspais.toml"
+    if repo_config_path.exists():
+        repo_config = load_config(repo_config_path)
     else:
-        core_config = config  # Use same config
+        repo_config = config  # Use same config
 
-    spec_dir = core_path / core_config.get("directories", {}).get("spec", "spec")
+    spec_dir = repo_path / repo_config.get("directories", {}).get("spec", "spec")
     if not spec_dir.exists():
         return {}
 
-    pattern_config = PatternConfig.from_dict(core_config.get("patterns", {}))
-    spec_config = core_config.get("spec", {})
+    pattern_config = PatternConfig.from_dict(repo_config.get("patterns", {}))
+    spec_config = repo_config.get("spec", {})
     no_reference_values = spec_config.get("no_reference_values")
     parser = RequirementParser(pattern_config, no_reference_values=no_reference_values)
     skip_files = spec_config.get("skip_files", [])
@@ -368,21 +391,26 @@ def format_requirements_json(
 
         # Check for specific violation types
         is_cycle = any("cycle" in v.rule_name.lower() for v in req_violations)
-        is_conflict = any(
+
+        # Use the model's is_conflict flag directly, or check violations for older behavior
+        is_conflict = req.is_conflict or any(
             "conflict" in v.rule_name.lower() or "duplicate" in v.rule_name.lower()
             for v in req_violations
         )
-        conflict_with = None
+        conflict_with = req.conflict_with if req.conflict_with else None
         cycle_path = None
 
+        # Also check violations for additional context
         for v in req_violations:
-            if "duplicate" in v.rule_name.lower():
+            if "duplicate" in v.rule_name.lower() and not conflict_with:
                 # Try to extract conflicting ID from message
                 conflict_with = v.message
             if "cycle" in v.rule_name.lower():
                 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
         output[req_id] = {
             "title": req.title,
             "status": req.status,

elspais/core/models.py

@@ -118,6 +118,8 @@ class Requirement:
     line_number: Optional[int] = None
     tags: List[str] = field(default_factory=list)
     subdir: str = ""  # Subdirectory within spec/, e.g., "roadmap", "archive", ""
+    is_conflict: bool = False  # True if this is a conflicting duplicate entry
+    conflict_with: str = ""  # ID of the original requirement this conflicts with
 
     @property
     def type_code(self) -> str:

elspais/core/parser.py

@@ -155,12 +155,12 @@ class RequirementParser:
                 if req:
                     # Check for duplicate ID
                     if req_id in requirements:
-                        warnings.append(ParseWarning(
-                            requirement_id=req_id,
-                            message=f"Duplicate ID ignored (first occurrence at line {requirements[req_id].line_number})",
-                            file_path=file_path,
-                            line_number=start_line,
-                        ))
+                        # Keep both: original stays, duplicate gets __conflict suffix
+                        conflict_key, conflict_req, warning = self._make_conflict_entry(
+                            req, req_id, requirements[req_id], file_path, start_line
+                        )
+                        requirements[conflict_key] = conflict_req
+                        warnings.append(warning)
                     else:
                         requirements[req_id] = req
             else:
@@ -221,12 +221,12 @@ class RequirementParser:
                     # Merge requirements, checking for cross-file duplicates
                     for req_id, req in result.requirements.items():
                         if req_id in requirements:
-                            warnings.append(ParseWarning(
-                                requirement_id=req_id,
-                                message=f"Duplicate ID ignored (first occurrence in {requirements[req_id].file_path})",
-                                file_path=file_path,
-                                line_number=req.line_number,
-                            ))
+                            # Keep both: original stays, duplicate gets __conflict suffix
+                            conflict_key, conflict_req, warning = self._make_conflict_entry(
+                                req, req_id, requirements[req_id], file_path, req.line_number
+                            )
+                            requirements[conflict_key] = conflict_req
+                            warnings.append(warning)
                         else:
                             requirements[req_id] = req
                     warnings.extend(result.warnings)
@@ -278,12 +278,12 @@ class RequirementParser:
                 # Merge requirements, checking for cross-directory duplicates
                 for req_id, req in result.requirements.items():
                     if req_id in requirements:
-                        warnings.append(ParseWarning(
-                            requirement_id=req_id,
-                            message=f"Duplicate ID ignored (first occurrence in {requirements[req_id].file_path})",
-                            file_path=req.file_path,
-                            line_number=req.line_number,
-                        ))
+                        # Keep both: original stays, duplicate gets __conflict suffix
+                        conflict_key, conflict_req, warning = self._make_conflict_entry(
+                            req, req_id, requirements[req_id], req.file_path, req.line_number
+                        )
+                        requirements[conflict_key] = conflict_req
+                        warnings.append(warning)
                     else:
                         requirements[req_id] = req
                 warnings.extend(result.warnings)
@@ -336,18 +336,62 @@ class RequirementParser:
                 # Merge requirements, checking for cross-subdir duplicates
                 for req_id, req in subdir_result.requirements.items():
                     if req_id in requirements:
-                        warnings.append(ParseWarning(
-                            requirement_id=req_id,
-                            message=f"Duplicate ID ignored (first occurrence in {requirements[req_id].file_path})",
-                            file_path=req.file_path,
-                            line_number=req.line_number,
-                        ))
+                        # Keep both: original stays, duplicate gets __conflict suffix
+                        conflict_key, conflict_req, warning = self._make_conflict_entry(
+                            req, req_id, requirements[req_id], req.file_path, req.line_number
+                        )
+                        requirements[conflict_key] = conflict_req
+                        warnings.append(warning)
                     else:
                         requirements[req_id] = req
                 warnings.extend(subdir_result.warnings)
 
         return ParseResult(requirements=requirements, warnings=warnings)
 
+    def _make_conflict_entry(
+        self,
+        duplicate_req: Requirement,
+        original_id: str,
+        original_req: Requirement,
+        file_path: Optional[Path],
+        line_number: Optional[int],
+    ) -> tuple:
+        """
+        Create a conflict entry for a duplicate requirement.
+
+        When a requirement ID already exists, this creates a modified version
+        of the duplicate with:
+        - Key suffix `__conflict` for storage
+        - `is_conflict=True` flag
+        - `conflict_with` set to the original ID
+        - `implements=[]` (treated as orphaned)
+
+        Args:
+            duplicate_req: The duplicate requirement that was found
+            original_id: The ID that is duplicated
+            original_req: The original requirement that was first
+            file_path: File path for the warning
+            line_number: Line number for the warning
+
+        Returns:
+            Tuple of (conflict_key, modified_requirement, ParseWarning)
+        """
+        conflict_key = f"{original_id}__conflict"
+
+        # Modify the duplicate requirement
+        duplicate_req.is_conflict = True
+        duplicate_req.conflict_with = original_id
+        duplicate_req.implements = []  # Treat as orphaned
+
+        warning = ParseWarning(
+            requirement_id=original_id,
+            message=f"Duplicate ID found (first occurrence in {original_req.file_path}:{original_req.line_number})",
+            file_path=file_path,
+            line_number=line_number,
+        )
+
+        return conflict_key, duplicate_req, warning
+
     def _parse_requirement_block(
         self,
         req_id: str,

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