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

elspais/commands/validate.py

@@ -13,10 +13,11 @@ from typing import Any, Dict, List, Optional
 from elspais.config.defaults import DEFAULT_CONFIG
 from elspais.config.loader import find_config_file, get_spec_directories, load_config
 from elspais.core.hasher import calculate_hash, verify_hash
-from elspais.core.models import Requirement
+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]}")
@@ -55,7 +69,8 @@ def run(args: argparse.Namespace) -> int:
     skip_files = spec_config.get("skip_files", [])
 
     try:
-        requirements = parser.parse_directories(spec_dirs, skip_files=skip_files)
+        parse_result = parser.parse_directories(spec_dirs, skip_files=skip_files)
+        requirements = dict(parse_result)  # ParseResult supports dict-like access
     except Exception as e:
         print(f"Error parsing requirements: {e}", file=sys.stderr)
         return 1
@@ -81,6 +96,10 @@ def run(args: argparse.Namespace) -> int:
     link_violations = validate_links(requirements, args, config)
     violations.extend(link_violations)
 
+    # Add parser warnings (duplicates, etc.) as violations
+    parse_violations = convert_parse_warnings_to_violations(parse_result.warnings)
+    violations.extend(parse_violations)
+
     # Filter skipped rules
     if args.skip_rule:
         violations = [
@@ -240,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())
@@ -276,24 +296,62 @@ def validate_links(
     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 convert_parse_warnings_to_violations(
+    warnings: List[ParseWarning],
+) -> List[RuleViolation]:
+    """Convert parser warnings (like duplicates) to rule violations.
+
+    The parser detects duplicate REQ IDs and generates ParseWarning objects.
+    This function converts them to RuleViolation objects so they appear in
+    validation output.
+
+    Args:
+        warnings: List of ParseWarning objects from parser
+
+    Returns:
+        List of RuleViolation objects for duplicate IDs
+    """
+    violations = []
+    for warning in warnings:
+        if "duplicate" in warning.message.lower():
+            violations.append(
+                RuleViolation(
+                    rule_name="id.duplicate",
+                    requirement_id=warning.requirement_id,
+                    message=warning.message,
+                    severity=Severity.ERROR,
+                    location=f"{warning.file_path}:{warning.line_number}",
+                )
+            )
+    return violations
+
+
+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", [])
@@ -333,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/git.py

@@ -0,0 +1,352 @@
+"""
+Git state management for elspais.
+
+Provides functions to query git status and detect changes to requirement files,
+enabling detection of:
+- Uncommitted changes to spec files
+- New (untracked) requirement files
+- Files changed vs main/master branch
+- Moved requirements (comparing current location to committed state)
+"""
+
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+
+@dataclass
+class GitChangeInfo:
+    """Information about git changes to requirement files."""
+
+    modified_files: Set[str] = field(default_factory=set)
+    """Files with uncommitted modifications (staged or unstaged)."""
+
+    untracked_files: Set[str] = field(default_factory=set)
+    """New files not yet tracked by git."""
+
+    branch_changed_files: Set[str] = field(default_factory=set)
+    """Files changed between current branch and main/master."""
+
+    committed_req_locations: Dict[str, str] = field(default_factory=dict)
+    """REQ ID -> file path mapping from committed state (HEAD)."""
+
+    @property
+    def all_changed_files(self) -> Set[str]:
+        """Get all files with any kind of change."""
+        return self.modified_files | self.untracked_files | self.branch_changed_files
+
+    @property
+    def uncommitted_files(self) -> Set[str]:
+        """Get all files with uncommitted changes (modified or untracked)."""
+        return self.modified_files | self.untracked_files
+
+
+@dataclass
+class MovedRequirement:
+    """Information about a requirement that was moved between files."""
+
+    req_id: str
+    """The requirement ID (e.g., 'd00001')."""
+
+    old_path: str
+    """Path in the committed state."""
+
+    new_path: str
+    """Path in the current working directory."""
+
+
+def get_repo_root(start_path: Optional[Path] = None) -> Optional[Path]:
+    """Find the git repository root.
+
+    Args:
+        start_path: Path to start searching from (default: current directory)
+
+    Returns:
+        Path to repository root, or None if not in a git repository
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=start_path or Path.cwd(),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return Path(result.stdout.strip())
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+def get_modified_files(repo_root: Path) -> Tuple[Set[str], Set[str]]:
+    """Get sets of modified and untracked files according to git status.
+
+    Args:
+        repo_root: Path to repository root
+
+    Returns:
+        Tuple of (modified_files, untracked_files):
+        - modified_files: Tracked files with changes (M, A, R, etc.)
+        - untracked_files: New files not yet tracked (??)
+    """
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain", "--untracked-files=all"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        modified_files: Set[str] = set()
+        untracked_files: Set[str] = set()
+
+        for line in result.stdout.split("\n"):
+            if line and len(line) >= 3:
+                # Format: "XY filename" or "XY orig -> renamed"
+                # XY = two-letter status (e.g., " M", "??", "A ", "R ")
+                status_code = line[:2]
+                file_path = line[3:].strip()
+
+                # Handle renames: "orig -> new"
+                if " -> " in file_path:
+                    file_path = file_path.split(" -> ")[1]
+
+                if file_path:
+                    if status_code == "??":
+                        untracked_files.add(file_path)
+                    else:
+                        modified_files.add(file_path)
+
+        return modified_files, untracked_files
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return set(), set()
+
+
+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:
+        repo_root: Path to repository root
+        base_branch: Name of base branch (default: 'main')
+
+    Returns:
+        Set of file paths changed vs base branch
+    """
+    # Try local branch first, then remote
+    for branch_ref in [base_branch, f"origin/{base_branch}"]:
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--name-only", f"{branch_ref}...HEAD"],
+                cwd=repo_root,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            changed_files: Set[str] = set()
+            for line in result.stdout.split("\n"):
+                if line.strip():
+                    changed_files.add(line.strip())
+            return changed_files
+        except subprocess.CalledProcessError:
+            continue
+        except FileNotFoundError:
+            return set()
+
+    return set()
+
+
+def get_committed_req_locations(
+    repo_root: Path,
+    spec_dir: str = "spec",
+    exclude_files: Optional[List[str]] = None,
+) -> Dict[str, str]:
+    """Get REQ ID -> file path mapping from committed state (HEAD).
+
+    This allows detection of moved requirements by comparing current location
+    to where the REQ was in the last commit.
+
+    Args:
+        repo_root: Path to repository root
+        spec_dir: Spec directory relative to repo root
+        exclude_files: Files to exclude (default: INDEX.md, README.md)
+
+    Returns:
+        Dict mapping REQ ID (e.g., 'd00001') to relative file path
+    """
+    if exclude_files is None:
+        exclude_files = ["INDEX.md", "README.md", "requirements-format.md"]
+
+    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
+    )
+
+    try:
+        # Get list of spec files in committed state
+        result = subprocess.run(
+            ["git", "ls-tree", "-r", "--name-only", "HEAD", f"{spec_dir}/"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        for file_path in result.stdout.strip().split("\n"):
+            if not file_path.endswith(".md"):
+                continue
+            if any(skip in file_path for skip in exclude_files):
+                continue
+
+            # Get file content from committed state
+            try:
+                content_result = subprocess.run(
+                    ["git", "show", f"HEAD:{file_path}"],
+                    cwd=repo_root,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                content = content_result.stdout
+
+                # Find all REQ IDs in this file
+                for match in req_pattern.finditer(content):
+                    req_id = match.group(1)
+                    req_locations[req_id] = file_path
+
+            except subprocess.CalledProcessError:
+                # File might not exist in HEAD (new file)
+                continue
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+
+    return req_locations
+
+
+def get_current_req_locations(
+    repo_root: Path,
+    spec_dir: str = "spec",
+    exclude_files: Optional[List[str]] = None,
+) -> Dict[str, str]:
+    """Get REQ ID -> file path mapping from current working directory.
+
+    Args:
+        repo_root: Path to repository root
+        spec_dir: Spec directory relative to repo root
+        exclude_files: Files to exclude (default: INDEX.md, README.md)
+
+    Returns:
+        Dict mapping REQ ID (e.g., 'd00001') to relative file path
+    """
+    if exclude_files is None:
+        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
+    )
+
+    spec_path = repo_root / spec_dir
+    if not spec_path.exists():
+        return req_locations
+
+    for md_file in spec_path.rglob("*.md"):
+        if any(skip in md_file.name for skip in exclude_files):
+            continue
+
+        try:
+            content = md_file.read_text(encoding="utf-8")
+            rel_path = str(md_file.relative_to(repo_root))
+
+            for match in req_pattern.finditer(content):
+                req_id = match.group(1)
+                req_locations[req_id] = rel_path
+
+        except (IOError, UnicodeDecodeError):
+            continue
+
+    return req_locations
+
+
+def detect_moved_requirements(
+    committed_locations: Dict[str, str],
+    current_locations: Dict[str, str],
+) -> List[MovedRequirement]:
+    """Detect requirements that have been moved between files.
+
+    Args:
+        committed_locations: REQ ID -> path mapping from committed state
+        current_locations: REQ ID -> path mapping from current state
+
+    Returns:
+        List of MovedRequirement objects for requirements whose location changed
+    """
+    moved = []
+    for req_id, old_path in committed_locations.items():
+        if req_id in current_locations:
+            new_path = current_locations[req_id]
+            if old_path != new_path:
+                moved.append(
+                    MovedRequirement(
+                        req_id=req_id,
+                        old_path=old_path,
+                        new_path=new_path,
+                    )
+                )
+    return moved
+
+
+def get_git_changes(
+    repo_root: Optional[Path] = None,
+    spec_dir: str = "spec",
+    base_branch: str = "main",
+) -> GitChangeInfo:
+    """Get comprehensive git change information for requirement files.
+
+    This is the main entry point for git change detection. It gathers:
+    - Modified files (uncommitted changes to tracked files)
+    - Untracked files (new files not yet in git)
+    - Branch changed files (files changed vs main/master)
+    - Committed REQ locations (for move detection)
+
+    Args:
+        repo_root: Path to repository root (auto-detected if None)
+        spec_dir: Spec directory relative to repo root
+        base_branch: Base branch for comparison (default: 'main')
+
+    Returns:
+        GitChangeInfo with all change information
+    """
+    if repo_root is None:
+        repo_root = get_repo_root()
+        if repo_root is None:
+            return GitChangeInfo()
+
+    modified, untracked = get_modified_files(repo_root)
+    branch_changed = get_changed_vs_branch(repo_root, base_branch)
+    committed_locations = get_committed_req_locations(repo_root, spec_dir)
+
+    return GitChangeInfo(
+        modified_files=modified,
+        untracked_files=untracked,
+        branch_changed_files=branch_changed,
+        committed_req_locations=committed_locations,
+    )
+
+
+def filter_spec_files(files: Set[str], spec_dir: str = "spec") -> Set[str]:
+    """Filter a set of files to only include spec directory files.
+
+    Args:
+        files: Set of file paths
+        spec_dir: Spec directory prefix
+
+    Returns:
+        Set of files that are in the spec directory
+    """
+    prefix = f"{spec_dir}/"
+    return {f for f in files if f.startswith(prefix) and f.endswith(".md")}

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,