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

elspais/core/git.py

@@ -1,346 +0,0 @@
-"""
-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 (OSError, 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

@@ -1,320 +0,0 @@
-"""
-elspais.core.models - Core data models for requirements.
-
-Provides dataclasses for representing requirements, parsed IDs,
-and requirement types.
-"""
-
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Dict, List, Optional
-
-
-@dataclass
-class RequirementType:
-    """
-    Represents a requirement type (PRD, OPS, DEV, etc.).
-
-    Attributes:
-        id: The type identifier used in requirement IDs (e.g., "p", "PRD")
-        name: Human-readable name (e.g., "Product Requirement")
-        level: Hierarchy level (1=highest/parent, higher numbers=children)
-    """
-
-    id: str
-    name: str = ""
-    level: int = 1
-
-
-@dataclass
-class Assertion:
-    """
-    Represents a single assertion within a requirement.
-
-    Assertions are the unit of verification - each defines one testable
-    obligation using SHALL/SHALL NOT language.
-
-    Attributes:
-        label: The assertion label (e.g., "A", "B", "01", "0A")
-        text: The assertion text (e.g., "The system SHALL...")
-        is_placeholder: True if text indicates removed/deprecated assertion
-    """
-
-    label: str
-    text: str
-    is_placeholder: bool = False
-
-    @property
-    def full_id(self) -> str:
-        """Return the assertion ID suffix (e.g., "-A")."""
-        return f"-{self.label}"
-
-    def __str__(self) -> str:
-        return f"{self.label}. {self.text}"
-
-
-@dataclass
-class ParsedRequirement:
-    """
-    Represents a parsed requirement ID broken into components.
-
-    Attributes:
-        full_id: The complete requirement ID (e.g., "REQ-CAL-p00001" or "REQ-p00001-A")
-        prefix: The ID prefix (e.g., "REQ")
-        associated: Optional associated repo namespace (e.g., "CAL")
-        type_code: The requirement type code (e.g., "p")
-        number: The ID number or name (e.g., "00001")
-        assertion: Optional assertion label (e.g., "A", "01")
-    """
-
-    full_id: str
-    prefix: str
-    associated: Optional[str]
-    type_code: str
-    number: str
-    assertion: Optional[str] = None
-
-    @property
-    def base_id(self) -> str:
-        """Return the requirement ID without assertion suffix."""
-        if self.assertion:
-            return self.full_id.rsplit("-", 1)[0]
-        return self.full_id
-
-
-@dataclass
-class Requirement:
-    """
-    Represents a complete requirement specification.
-
-    Attributes:
-        id: Unique requirement identifier (e.g., "REQ-p00001")
-        title: Requirement title
-        level: Requirement level/type name (e.g., "PRD", "DEV")
-        status: Current status (e.g., "Active", "Draft")
-        body: Main requirement text
-        implements: List of requirement IDs this requirement implements
-        acceptance_criteria: List of acceptance criteria (legacy format)
-        assertions: List of Assertion objects (new format)
-        rationale: Optional rationale text
-        hash: Content hash for change detection
-        file_path: Source file path
-        line_number: Line number in source file
-        tags: Optional list of tags
-    """
-
-    id: str
-    title: str
-    level: str
-    status: str
-    body: str
-    implements: List[str] = field(default_factory=list)
-    acceptance_criteria: List[str] = field(default_factory=list)
-    assertions: List["Assertion"] = field(default_factory=list)
-    rationale: Optional[str] = None
-    hash: Optional[str] = None
-    file_path: Optional[Path] = None
-    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:
-        """
-        Extract the type code from the requirement ID.
-
-        For REQ-p00001, returns "p".
-        For REQ-CAL-d00001, returns "d".
-        For PRD-00001, returns "PRD".
-        """
-        # Try to extract type code from ID
-        # Pattern: after last separator, before numbers
-        match = re.search(r"-([a-zA-Z]+)\d", self.id)
-        if match:
-            return match.group(1)
-
-        # Pattern: type at start (e.g., PRD-00001)
-        match = re.match(r"([A-Z]+)-\d", self.id)
-        if match:
-            return match.group(1)
-
-        return ""
-
-    @property
-    def number(self) -> int:
-        """
-        Extract the numeric ID from the requirement ID.
-
-        For REQ-p00001, returns 1.
-        For REQ-d00042, returns 42.
-        """
-        match = re.search(r"(\d+)$", self.id)
-        if match:
-            return int(match.group(1))
-        return 0
-
-    @property
-    def associated(self) -> Optional[str]:
-        """
-        Extract the associated repo code from the requirement ID.
-
-        For REQ-CAL-d00001, returns "CAL".
-        For REQ-p00001, returns None.
-        """
-        # Pattern: REQ-XXX- where XXX is 2-4 uppercase letters
-        match = re.search(r"^[A-Z]+-([A-Z]{2,4})-", self.id)
-        if match:
-            return match.group(1)
-        return None
-
-    @property
-    def is_roadmap(self) -> bool:
-        """
-        Check if this requirement is from the roadmap subdirectory.
-
-        Returns True if subdir is "roadmap", False otherwise.
-        This is a convenience property for backward compatibility.
-        """
-        return self.subdir == "roadmap"
-
-    @property
-    def spec_path(self) -> str:
-        """
-        Return the spec-relative file path as a string.
-
-        For requirements in spec/prd-core.md, returns "spec/prd-core.md".
-        For requirements in spec/roadmap/prd-future.md, returns "spec/roadmap/prd-future.md".
-        """
-        if self.file_path:
-            return str(self.file_path)
-        return ""
-
-    def location(self) -> str:
-        """Return file:line location string."""
-        if self.file_path and self.line_number:
-            return f"{self.file_path}:{self.line_number}"
-        elif self.file_path:
-            return str(self.file_path)
-        return "unknown"
-
-    def get_assertion(self, label: str) -> Optional["Assertion"]:
-        """Get an assertion by its label."""
-        for assertion in self.assertions:
-            if assertion.label == label:
-                return assertion
-        return None
-
-    def assertion_id(self, label: str) -> str:
-        """Return the full assertion ID (e.g., 'REQ-p00001-A')."""
-        return f"{self.id}-{label}"
-
-    def __str__(self) -> str:
-        return f"{self.id}: {self.title}"
-
-    def __repr__(self) -> str:
-        return f"Requirement(id={self.id!r}, title={self.title!r}, level={self.level!r})"
-
-
-@dataclass
-class ContentRule:
-    """
-    Represents a content rule file for semantic validation guidance.
-
-    Content rules are markdown files that provide guidance to AI agents
-    and humans when authoring requirements. They can include YAML frontmatter
-    for metadata.
-
-    Attributes:
-        file_path: Path to the content rule file
-        title: Human-readable title (from frontmatter or filename)
-        content: Full markdown content (excluding frontmatter)
-        type: Rule type - "guidance", "specification", or "template"
-        applies_to: List of what this rule applies to (e.g., ["requirements", "assertions"])
-    """
-
-    file_path: Path
-    title: str
-    content: str
-    type: str = "guidance"
-    applies_to: List[str] = field(default_factory=list)
-
-
-@dataclass
-class ParseWarning:
-    """
-    Parser-level warning about a requirement.
-
-    Warnings indicate issues found during parsing that don't prevent
-    the requirement from being parsed, but may indicate problems.
-
-    Attributes:
-        requirement_id: The requirement ID this warning relates to
-        message: Human-readable warning message
-        file_path: Source file path (optional)
-        line_number: Line number in source file (optional)
-    """
-
-    requirement_id: str
-    message: str
-    file_path: Optional[Path] = None
-    line_number: Optional[int] = None
-
-    def __str__(self) -> str:
-        location = ""
-        if self.file_path:
-            location = f" at {self.file_path}"
-            if self.line_number:
-                location = f" at {self.file_path}:{self.line_number}"
-        return f"[{self.requirement_id}] {self.message}{location}"
-
-
-@dataclass
-class ParseResult:
-    """
-    Result of parsing requirements from text or files.
-
-    Contains both the successfully parsed requirements and any
-    warnings generated during parsing.
-
-    Attributes:
-        requirements: Dictionary of requirement ID to Requirement
-        warnings: List of parser warnings
-    """
-
-    requirements: Dict[str, "Requirement"]
-    warnings: List[ParseWarning] = field(default_factory=list)
-
-    def __getitem__(self, key: str) -> "Requirement":
-        """Get a requirement by ID."""
-        return self.requirements[key]
-
-    def __contains__(self, key: str) -> bool:
-        """Check if a requirement ID exists."""
-        return key in self.requirements
-
-    def __len__(self) -> int:
-        """Return the number of requirements."""
-        return len(self.requirements)
-
-    def __iter__(self):
-        """Iterate over requirement IDs."""
-        return iter(self.requirements)
-
-    def items(self):
-        """Return items like a dict."""
-        return self.requirements.items()
-
-    def keys(self):
-        """Return keys like a dict."""
-        return self.requirements.keys()
-
-    def values(self):
-        """Return values like a dict."""
-        return self.requirements.values()
-
-    def get(self, key: str, default=None) -> Optional["Requirement"]:
-        """Get a requirement by ID with default."""
-        return self.requirements.get(key, default)