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

elspais/commands/analyze.py

@@ -1,217 +1,166 @@
+# Implements: REQ-int-d00003 (CLI Extension)
 """
 elspais.commands.analyze - Analyze requirements command.
+
+Uses graph-based system for analysis:
+- `elspais analyze hierarchy` - Display requirement hierarchy tree
+- `elspais analyze orphans` - Find orphaned requirements
+- `elspais analyze coverage` - Show implementation coverage report
 """
 
+from __future__ import annotations
+
 import argparse
 import sys
-from pathlib import Path
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from elspais.graph.builder import TraceGraph
 
-from elspais.config.defaults import DEFAULT_CONFIG
-from elspais.config.loader import find_config_file, get_spec_directories, load_config
-from elspais.core.models import Requirement
-from elspais.core.parser import RequirementParser
-from elspais.core.patterns import PatternConfig
+from elspais.graph import GraphNode, NodeKind
 
 
 def run(args: argparse.Namespace) -> int:
     """Run the analyze command."""
-    if not args.analyze_action:
-        print("Usage: elspais analyze {hierarchy|orphans|coverage}")
-        return 1
+    from elspais.graph.factory import build_graph
 
-    if args.analyze_action == "hierarchy":
-        return run_hierarchy(args)
-    elif args.analyze_action == "orphans":
-        return run_orphans(args)
-    elif args.analyze_action == "coverage":
-        return run_coverage(args)
+    spec_dir = getattr(args, "spec_dir", None)
+    config_path = getattr(args, "config", None)
 
-    return 1
+    graph = build_graph(
+        spec_dirs=[spec_dir] if spec_dir else None,
+        config_path=config_path,
+    )
 
+    action = getattr(args, "analyze_action", None)
 
-def run_hierarchy(args: argparse.Namespace) -> int:
-    """Show requirement hierarchy tree."""
-    requirements = load_requirements(args)
-    if not requirements:
+    if action == "hierarchy":
+        return _analyze_hierarchy(graph, args)
+    elif action == "orphans":
+        return _analyze_orphans(graph, args)
+    elif action == "coverage":
+        return _analyze_coverage(graph, args)
+    else:
+        print("Usage: elspais analyze <hierarchy|orphans|coverage>", file=sys.stderr)
         return 1
 
+
+def _analyze_hierarchy(graph: TraceGraph, args: argparse.Namespace) -> int:
+    """Display requirement hierarchy tree."""
     print("Requirement Hierarchy")
     print("=" * 60)
 
-    # Find root requirements (PRD with no implements)
-    roots = [
-        req
-        for req in requirements.values()
-        if req.level.upper() in ["PRD", "PRODUCT"] and not req.implements
-    ]
-
-    if not roots:
-        # Fall back to all PRD requirements
-        roots = [req for req in requirements.values() if req.level.upper() in ["PRD", "PRODUCT"]]
+    # Find root requirements (PRD level or no parents)
+    roots = []
+    for node in graph.nodes_by_kind(NodeKind.REQUIREMENT):
+        level = (node.level or "").upper()
+        if level == "PRD" or node.parent_count() == 0:
+            # Check if this has no parent requirements
+            has_req_parent = False
+            for parent in node.iter_parents():
+                if parent.kind == NodeKind.REQUIREMENT:
+                    has_req_parent = True
+                    break
+            if not has_req_parent:
+                roots.append(node)
 
-    printed = set()
+    for root in sorted(roots, key=lambda n: n.id):
+        _print_tree(root, indent=0)
 
-    def print_tree(req: Requirement, indent: int = 0) -> None:
-        if req.id in printed:
-            return
-        printed.add(req.id)
+    return 0
 
-        prefix = "  " * indent
-        status_icon = "✓" if req.status == "Active" else "○"
-        print(f"{prefix}{status_icon} {req.id}: {req.title}")
 
-        # Find children (requirements that implement this one)
-        children = find_children(req.id, requirements)
-        for child in children:
-            print_tree(child, indent + 1)
+def _print_tree(node: GraphNode, indent: int) -> None:
+    """Recursively print node and children."""
+    prefix = "  " * indent
+    status_icon = "[x]" if (node.status or "").lower() == "active" else "[ ]"
+    level = node.level or "?"
+    print(f"{prefix}{status_icon} {node.id} ({level}) - {node.get_label()}")
 
-    for root in sorted(roots, key=lambda r: r.id):
-        print_tree(root)
-        print()
+    # Get child requirements
+    children = []
+    for child in node.iter_children():
+        if child.kind == NodeKind.REQUIREMENT:
+            children.append(child)
 
-    return 0
+    for child in sorted(children, key=lambda n: n.id):
+        _print_tree(child, indent + 1)
 
 
-def run_orphans(args: argparse.Namespace) -> int:
+def _analyze_orphans(graph: TraceGraph, args: argparse.Namespace) -> int:
     """Find orphaned requirements."""
-    requirements = load_requirements(args)
-    if not requirements:
-        return 1
-
     orphans = []
 
-    for req in requirements.values():
-        # Skip PRD (they can be roots)
-        if req.level.upper() in ["PRD", "PRODUCT"]:
+    for node in graph.nodes_by_kind(NodeKind.REQUIREMENT):
+        level = (node.level or "").upper()
+        # PRD level should not have parents
+        if level == "PRD":
             continue
 
-        # Check if this requirement implements anything
-        if not req.implements:
-            orphans.append(req)
-        else:
-            # Check if all implements references are valid
-            all_valid = True
-            for impl_id in req.implements:
-                if not find_requirement(impl_id, requirements):
-                    all_valid = False
-                    break
-            if not all_valid:
-                orphans.append(req)
-
-    if orphans:
-        print(f"Orphaned Requirements ({len(orphans)}):")
-        print("-" * 40)
-        for req in sorted(orphans, key=lambda r: r.id):
-            impl_str = ", ".join(req.implements) if req.implements else "(none)"
-            print(f"  {req.id}: {req.title}")
-            print(f"    Level: {req.level} | Implements: {impl_str}")
-            if req.file_path:
-                print(f"    File: {req.file_path.name}:{req.line_number}")
-            print()
-    else:
-        print("✓ No orphaned requirements found")
-
-    return 0
-
+        # Check for parent requirements
+        has_req_parent = False
+        for parent in node.iter_parents():
+            if parent.kind == NodeKind.REQUIREMENT:
+                has_req_parent = True
+                break
 
-def run_coverage(args: argparse.Namespace) -> int:
-    """Show implementation coverage report."""
-    requirements = load_requirements(args)
-    if not requirements:
-        return 1
+        if not has_req_parent:
+            orphans.append(node)
 
-    # Group by type
-    prd_count = sum(1 for r in requirements.values() if r.level.upper() in ["PRD", "PRODUCT"])
-    ops_count = sum(1 for r in requirements.values() if r.level.upper() in ["OPS", "OPERATIONS"])
-    dev_count = sum(1 for r in requirements.values() if r.level.upper() in ["DEV", "DEVELOPMENT"])
-
-    # Count PRD requirements that have implementations
-    implemented_prd = set()
-    for req in requirements.values():
-        for impl_id in req.implements:
-            # Resolve to full ID
-            target = find_requirement(impl_id, requirements)
-            if target and target.level.upper() in ["PRD", "PRODUCT"]:
-                implemented_prd.add(target.id)
-
-    print("Implementation Coverage Report")
-    print("=" * 60)
-    print()
-    print(f"Total Requirements: {len(requirements)}")
-    print(f"  PRD: {prd_count}")
-    print(f"  OPS: {ops_count}")
-    print(f"  DEV: {dev_count}")
-    print()
-    print("PRD Implementation Coverage:")
-    print(f"  Implemented: {len(implemented_prd)}/{prd_count}")
-    if prd_count > 0:
-        pct = (len(implemented_prd) / prd_count) * 100
-        print(f"  Coverage: {pct:.1f}%")
-
-    # List unimplemented PRD
-    unimplemented = [
-        req
-        for req in requirements.values()
-        if req.level.upper() in ["PRD", "PRODUCT"] and req.id not in implemented_prd
-    ]
-
-    if unimplemented:
+    if orphans:
+        print(f"Found {len(orphans)} orphaned requirements:")
         print()
-        print(f"Unimplemented PRD ({len(unimplemented)}):")
-        for req in sorted(unimplemented, key=lambda r: r.id):
-            print(f"  - {req.id}: {req.title}")
-
-    return 0
-
-
-def load_requirements(args: argparse.Namespace) -> Dict[str, Requirement]:
-    """Load requirements from spec directories."""
-    config_path = args.config or find_config_file(Path.cwd())
-    if config_path and config_path.exists():
-        config = load_config(config_path)
+        for node in sorted(orphans, key=lambda n: n.id):
+            loc = f"{node.source.path}:{node.source.line}" if node.source else "unknown"
+            print(f"  {node.id} ({node.level or '?'}) - {node.get_label()}")
+            print(f"    Location: {loc}")
     else:
-        config = DEFAULT_CONFIG
+        print("No orphaned requirements found.")
 
-    spec_dirs = get_spec_directories(args.spec_dir, config)
-    if not spec_dirs:
-        print("Error: No spec directories found", file=sys.stderr)
-        return {}
+    return 1 if orphans else 0
 
-    pattern_config = PatternConfig.from_dict(config.get("patterns", {}))
-    spec_config = config.get("spec", {})
-    no_reference_values = spec_config.get("no_reference_values")
-    skip_files = spec_config.get("skip_files", [])
-    parser = RequirementParser(pattern_config, no_reference_values=no_reference_values)
 
-    try:
-        return parser.parse_directories(spec_dirs, skip_files=skip_files)
-    except Exception as e:
-        print(f"Error parsing requirements: {e}", file=sys.stderr)
-        return {}
+def _analyze_coverage(graph: TraceGraph, args: argparse.Namespace) -> int:
+    """Show implementation coverage report."""
+    from elspais.graph.annotators import group_by_level
 
+    # Group requirements by level using shared utility
+    by_level = group_by_level(graph)
 
-def find_children(req_id: str, requirements: Dict[str, Requirement]) -> List[Requirement]:
-    """Find requirements that implement the given requirement."""
-    children = []
-    short_id = req_id.split("-")[-1] if "-" in req_id else req_id
+    print("Requirements by Level")
+    print("=" * 40)
+    for level, nodes in by_level.items():
+        if nodes:
+            print(f"  {level}: {len(nodes)}")
 
-    for other_req in requirements.values():
-        for impl in other_req.implements:
-            if impl == req_id or impl == short_id or impl.endswith(short_id):
-                children.append(other_req)
-                break
+    # PRD implementation coverage
+    prd_nodes = by_level["PRD"]
+    if prd_nodes:
+        print()
+        print("PRD Implementation Coverage")
+        print("-" * 40)
 
-    return sorted(children, key=lambda r: r.id)
+        implemented = []
+        unimplemented = []
 
+        for prd in prd_nodes:
+            has_children = False
+            for child in prd.iter_children():
+                if child.kind == NodeKind.REQUIREMENT:
+                    has_children = True
+                    break
+            if has_children:
+                implemented.append(prd)
+            else:
+                unimplemented.append(prd)
 
-def find_requirement(impl_id: str, requirements: Dict[str, Requirement]) -> Optional[Requirement]:
-    """Find a requirement by full or partial ID."""
-    if impl_id in requirements:
-        return requirements[impl_id]
+        pct = len(implemented) / len(prd_nodes) * 100 if prd_nodes else 0
+        print(f"  Implemented: {len(implemented)}/{len(prd_nodes)} ({pct:.1f}%)")
 
-    for req_id, req in requirements.items():
-        if req_id.endswith(impl_id) or req_id.endswith(f"-{impl_id}"):
-            return req
+        if unimplemented:
+            print()
+            print("  Unimplemented PRD requirements:")
+            for node in sorted(unimplemented, key=lambda n: n.id):
+                print(f"    {node.id} - {node.get_label()}")
 
-    return None
+    return 0

elspais/commands/changed.py

@@ -9,37 +9,26 @@ Detects changes to requirement files using git:
 
 import argparse
 import json
-import sys
-from pathlib import Path
 from typing import Dict, Optional
 
-from elspais.config.defaults import DEFAULT_CONFIG
-from elspais.config.loader import find_config_file, load_config
-from elspais.core.git import (
+from elspais.utilities.git import (
     detect_moved_requirements,
     filter_spec_files,
-    get_current_req_locations,
     get_git_changes,
     get_repo_root,
+    get_req_locations_from_graph,
 )
 
 
 def load_configuration(args: argparse.Namespace) -> Optional[Dict]:
-    """Load configuration from file or use defaults."""
-    config_path = getattr(args, "config", None)
-    if config_path:
-        pass  # Use provided path
-    else:
-        config_path = find_config_file(Path.cwd())
-
-    if config_path and config_path.exists():
-        try:
-            return load_config(config_path)
-        except Exception as e:
-            print(f"Error loading config: {e}", file=sys.stderr)
-            return None
-    else:
-        return DEFAULT_CONFIG
+    """Load configuration from file or use defaults.
+
+    Note: This is a wrapper for get_config() that returns Optional[Dict]
+    for backward compatibility. New code should use get_config() directly.
+    """
+    from elspais.config import get_config
+
+    return get_config(config_path=getattr(args, "config", None))
 
 
 def run(args: argparse.Namespace) -> int:
@@ -72,8 +61,8 @@ def run(args: argparse.Namespace) -> int:
     spec_untracked = filter_spec_files(changes.untracked_files, spec_dir)
     spec_branch = filter_spec_files(changes.branch_changed_files, spec_dir)
 
-    # Detect moved requirements
-    current_locations = get_current_req_locations(repo_root, spec_dir)
+    # Detect moved requirements using graph-based approach
+    current_locations = get_req_locations_from_graph(repo_root)
     moved = detect_moved_requirements(changes.committed_req_locations, current_locations)
 
     # Build result

elspais/commands/config_cmd.py

@@ -10,12 +10,7 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
-from elspais.config.defaults import DEFAULT_CONFIG
-from elspais.config.loader import (
-    find_config_file,
-    load_config,
-    parse_toml,
-)
+from elspais.config import DEFAULT_CONFIG, find_config_file, load_config, parse_toml
 
 
 def run(args: argparse.Namespace) -> int:
@@ -57,7 +52,7 @@ def cmd_show(args: argparse.Namespace) -> int:
         print("No configuration file found. Run 'elspais init' to create one.")
         return 1
 
-    config = load_config(config_path)
+    config = load_config(config_path).get_raw()
     section = getattr(args, "section", None)
 
     if section:
@@ -83,14 +78,16 @@ def cmd_get(args: argparse.Namespace) -> int:
         print("No configuration file found.", file=sys.stderr)
         return 1
 
-    config = load_config(config_path)
+    config_loader = load_config(config_path)
     key = args.key
 
-    value = _get_by_path(config, key)
+    # Use ConfigLoader.get() for dot-notation access
+    value = config_loader.get(key)
     if value is None:
-        # Check if it's truly None vs not found
+        # Check if it's truly None vs not found using raw dict
+        raw = config_loader.get_raw()
         parts = key.split(".")
-        current = config
+        current = raw
         for part in parts[:-1]:
             if part not in current:
                 print(f"Key not found: {key}", file=sys.stderr)
@@ -214,8 +211,8 @@ def cmd_remove(args: argparse.Namespace) -> int:
     user_config = _load_user_config(config_path)
     merged_config = load_config(config_path)
 
-    # Get current merged value to see what's there
-    current = _get_by_path(merged_config, key)
+    # Get current merged value using ConfigLoader.get() for dot-notation access
+    current = merged_config.get(key)
 
     if current is None or not isinstance(current, list):
         print(f"Error: {key} is not an array or doesn't exist", file=sys.stderr)

elspais/commands/edit.py

@@ -18,8 +18,7 @@ from typing import Any, Dict, List, Optional
 
 def run(args: argparse.Namespace) -> int:
     """Run the edit command."""
-    from elspais.config.defaults import DEFAULT_CONFIG
-    from elspais.config.loader import find_config_file, get_spec_directories, load_config
+    from elspais.config import DEFAULT_CONFIG, find_config_file, get_spec_directories, load_config
 
     # Load configuration
     config_path = args.config if hasattr(args, "config") else None
@@ -50,7 +49,7 @@ def run(args: argparse.Namespace) -> int:
 
     # Handle single edit mode
     if hasattr(args, "req_id") and args.req_id:
-        return run_single_edit(args, base_spec_dir, dry_run)
+        return run_single_edit(args, base_spec_dir, dry_run, validate_refs)
 
     print("Error: Must specify --req-id or --from-json", file=sys.stderr)
     return 1
@@ -95,7 +94,9 @@ def run_batch_edit(
     return 0
 
 
-def run_single_edit(args: argparse.Namespace, spec_dir: Path, dry_run: bool) -> int:
+def run_single_edit(
+    args: argparse.Namespace, spec_dir: Path, dry_run: bool, validate_refs: bool = False
+) -> int:
     """Run single requirement edit."""
     req_id = args.req_id
 
@@ -108,9 +109,28 @@ def run_single_edit(args: argparse.Namespace, spec_dir: Path, dry_run: bool) ->
     file_path = location["file_path"]
     results = []
 
+    # Collect valid refs if validation is enabled
+    valid_refs: Optional[set] = None
+    if validate_refs:
+        valid_refs = collect_all_req_ids(spec_dir)
+
     # Apply implements change
     if hasattr(args, "implements") and args.implements is not None:
         impl_list = [i.strip() for i in args.implements.split(",")]
+
+        # Validate references if enabled
+        if validate_refs and valid_refs:
+            invalid_refs = []
+            for ref in impl_list:
+                if ref not in valid_refs and f"REQ-{ref}" not in valid_refs:
+                    invalid_refs.append(ref)
+            if invalid_refs:
+                print(
+                    f"Error: Invalid implements references: {', '.join(invalid_refs)}",
+                    file=sys.stderr,
+                )
+                return 1
+
         result = modify_implements(file_path, req_id, impl_list, dry_run=dry_run)
         results.append(("implements", result))
 
@@ -156,8 +176,8 @@ def find_requirement_in_files(
     Returns:
         Dict with file_path, req_id, line_number, or None if not found
     """
-    # Pattern to match requirement header
-    pattern = re.compile(rf"^#\s*{re.escape(req_id)}:", re.MULTILINE)
+    # Pattern to match requirement header (any markdown header level ##, ###, etc.)
+    pattern = re.compile(rf"^#+\s*{re.escape(req_id)}:", re.MULTILINE)
 
     for md_file in spec_dir.rglob("*.md"):
         content = md_file.read_text()
@@ -194,8 +214,8 @@ def modify_implements(
     """
     content = file_path.read_text()
 
-    # Find the requirement header
-    req_pattern = re.compile(rf"^(#\s*{re.escape(req_id)}:[^\n]*\n)", re.MULTILINE)
+    # Find the requirement header (any markdown header level)
+    req_pattern = re.compile(rf"^(#+\s*{re.escape(req_id)}:[^\n]*\n)", re.MULTILINE)
     req_match = req_pattern.search(content)
 
     if not req_match:
@@ -271,8 +291,8 @@ def modify_status(
     """
     content = file_path.read_text()
 
-    # Find the requirement header
-    req_pattern = re.compile(rf"^(#\s*{re.escape(req_id)}:[^\n]*\n)", re.MULTILINE)
+    # Find the requirement header (any markdown header level)
+    req_pattern = re.compile(rf"^(#+\s*{re.escape(req_id)}:[^\n]*\n)", re.MULTILINE)
     req_match = req_pattern.search(content)
 
     if not req_match:
@@ -340,9 +360,9 @@ def move_requirement(
     source_content = source_file.read_text()
 
     # Find the requirement block
-    # Pattern: # REQ-xxx: title ... *End* *title* | **Hash**: xxx\n---
+    # Pattern: ## REQ-xxx: title ... *End* *title* | **Hash**: xxx\n---
     req_pattern = re.compile(
-        rf"(^#\s*{re.escape(req_id)}:[^\n]*\n" rf".*?" rf"\*End\*[^\n]*\n" rf"(?:---\n)?)",
+        rf"(^#+\s*{re.escape(req_id)}:[^\n]*\n" rf".*?" rf"\*End\*[^\n]*\n" rf"(?:---\n)?)",
         re.MULTILINE | re.DOTALL,
     )
 
@@ -399,7 +419,7 @@ def collect_all_req_ids(spec_dir: Path) -> set:
     import re
 
     req_ids = set()
-    pattern = re.compile(r"^#\s*(REQ-[A-Za-z0-9-]+):", re.MULTILINE)
+    pattern = re.compile(r"^#+\s*(REQ-[A-Za-z0-9-]+):", re.MULTILINE)
 
     for md_file in spec_dir.rglob("*.md"):
         content = md_file.read_text()