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

elspais/commands/analyze.py

@@ -1,218 +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"]
-        ]
-
-    printed = set()
-
-    def print_tree(req: Requirement, indent: int = 0) -> None:
-        if req.id in printed:
-            return
-        printed.add(req.id)
-
-        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)
-
-    for root in sorted(roots, key=lambda r: r.id):
-        print_tree(root)
-        print()
+    # 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)
+
+    for root in sorted(roots, key=lambda n: n.id):
+        _print_tree(root, indent=0)
 
     return 0
 
 
-def run_orphans(args: argparse.Namespace) -> int:
-    """Find orphaned requirements."""
-    requirements = load_requirements(args)
-    if not requirements:
-        return 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()}")
 
-    orphans = []
+    # Get child requirements
+    children = []
+    for child in node.iter_children():
+        if child.kind == NodeKind.REQUIREMENT:
+            children.append(child)
 
-    for req in requirements.values():
-        # Skip PRD (they can be roots)
-        if req.level.upper() in ["PRD", "PRODUCT"]:
-            continue
+    for child in sorted(children, key=lambda n: n.id):
+        _print_tree(child, indent + 1)
 
-        # 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")
+def _analyze_orphans(graph: TraceGraph, args: argparse.Namespace) -> int:
+    """Find orphaned requirements."""
+    orphans = []
 
-    return 0
+    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 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,39 +9,26 @@ Detects changes to requirement files using git:
 
 import argparse
 import json
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional
-
-from elspais.config.defaults import DEFAULT_CONFIG
-from elspais.config.loader import find_config_file, load_config
-from elspais.core.git import (
-    GitChangeInfo,
-    MovedRequirement,
+from typing import Dict, Optional
+
+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:
@@ -74,11 +61,9 @@ 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)
-    moved = detect_moved_requirements(
-        changes.committed_req_locations, current_locations
-    )
+    # 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
     result = {

elspais/commands/config_cmd.py

@@ -8,15 +8,9 @@ import argparse
 import json
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple
 
-from elspais.config.loader import (
-    find_config_file,
-    load_config,
-    merge_configs,
-    parse_toml,
-)
-from elspais.config.defaults import DEFAULT_CONFIG
+from elspais.config import DEFAULT_CONFIG, find_config_file, load_config, parse_toml
 
 
 def run(args: argparse.Namespace) -> int:
@@ -58,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:
@@ -84,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)
@@ -215,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)
@@ -255,6 +251,7 @@ def cmd_path(args: argparse.Namespace) -> int:
 
 # Helper functions
 
+
 def _get_config_path(args: argparse.Namespace) -> Optional[Path]:
     """Get configuration file path from args or by discovery."""
     if hasattr(args, "config") and args.config:
@@ -363,7 +360,7 @@ def _print_value(value: Any, prefix: str = "") -> None:
         if prefix:
             print(f"{prefix} = {'true' if value else 'false'}")
         else:
-            print('true' if value else 'false')
+            print("true" if value else "false")
     elif isinstance(value, str):
         if prefix:
             print(f'{prefix} = "{value}"')