elspais 0.9.1__py3-none-any.whl

elspais/commands/analyze.py

@@ -0,0 +1,218 @@
+"""
+elspais.commands.analyze - Analyze requirements command.
+"""
+
+import argparse
+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, get_spec_directories, load_config
+from elspais.core.models import Requirement
+from elspais.core.parser import RequirementParser
+from elspais.core.patterns import PatternConfig
+
+
+def run(args: argparse.Namespace) -> int:
+    """Run the analyze command."""
+    if not args.analyze_action:
+        print("Usage: elspais analyze {hierarchy|orphans|coverage}")
+        return 1
+
+    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)
+
+    return 1
+
+
+def run_hierarchy(args: argparse.Namespace) -> int:
+    """Show requirement hierarchy tree."""
+    requirements = load_requirements(args)
+    if not requirements:
+        return 1
+
+    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()
+
+    return 0
+
+
+def run_orphans(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"]:
+            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
+
+
+def run_coverage(args: argparse.Namespace) -> int:
+    """Show implementation coverage report."""
+    requirements = load_requirements(args)
+    if not requirements:
+        return 1
+
+    # 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:
+        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)
+    else:
+        config = DEFAULT_CONFIG
+
+    spec_dirs = get_spec_directories(args.spec_dir, config)
+    if not spec_dirs:
+        print("Error: No spec directories found", file=sys.stderr)
+        return {}
+
+    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 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
+
+    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
+
+    return sorted(children, key=lambda r: r.id)
+
+
+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]
+
+    for req_id, req in requirements.items():
+        if req_id.endswith(impl_id) or req_id.endswith(f"-{impl_id}"):
+            return req
+
+    return None

elspais/commands/config_cmd.py

@@ -0,0 +1,501 @@
+"""
+elspais.commands.config_cmd - Configuration management command.
+
+View and modify .elspais.toml configuration.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from elspais.config.loader import (
+    find_config_file,
+    load_config,
+    merge_configs,
+    parse_toml,
+)
+from elspais.config.defaults import DEFAULT_CONFIG
+
+
+def run(args: argparse.Namespace) -> int:
+    """
+    Run the config command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success)
+    """
+    action = getattr(args, "config_action", None)
+
+    if action == "show":
+        return cmd_show(args)
+    elif action == "get":
+        return cmd_get(args)
+    elif action == "set":
+        return cmd_set(args)
+    elif action == "unset":
+        return cmd_unset(args)
+    elif action == "add":
+        return cmd_add(args)
+    elif action == "remove":
+        return cmd_remove(args)
+    elif action == "path":
+        return cmd_path(args)
+    else:
+        # Default to show
+        return cmd_show(args)
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    """Show current configuration."""
+    config_path = _get_config_path(args)
+
+    if not config_path:
+        print("No configuration file found. Run 'elspais init' to create one.")
+        return 1
+
+    config = load_config(config_path)
+    section = getattr(args, "section", None)
+
+    if section:
+        value = _get_by_path(config, section)
+        if value is None:
+            print(f"Section not found: {section}", file=sys.stderr)
+            return 1
+        _print_value(value, section)
+    else:
+        if getattr(args, "json", False):
+            print(json.dumps(config, indent=2))
+        else:
+            _print_config(config)
+
+    return 0
+
+
+def cmd_get(args: argparse.Namespace) -> int:
+    """Get a specific configuration value."""
+    config_path = _get_config_path(args)
+
+    if not config_path:
+        print("No configuration file found.", file=sys.stderr)
+        return 1
+
+    config = load_config(config_path)
+    key = args.key
+
+    value = _get_by_path(config, key)
+    if value is None:
+        # Check if it's truly None vs not found
+        parts = key.split(".")
+        current = config
+        for part in parts[:-1]:
+            if part not in current:
+                print(f"Key not found: {key}", file=sys.stderr)
+                return 1
+            current = current[part]
+        if parts[-1] not in current:
+            print(f"Key not found: {key}", file=sys.stderr)
+            return 1
+
+    if getattr(args, "json", False):
+        print(json.dumps(value))
+    else:
+        _print_value(value)
+
+    return 0
+
+
+def cmd_set(args: argparse.Namespace) -> int:
+    """Set a configuration value."""
+    config_path = _get_config_path(args)
+
+    if not config_path:
+        config_path = Path.cwd() / ".elspais.toml"
+        print(f"Creating new configuration file: {config_path}")
+
+    key = args.key
+    value = args.value
+
+    # Parse value with type inference
+    parsed_value = _parse_cli_value(value)
+
+    # Load existing user config (not merged with defaults)
+    user_config = _load_user_config(config_path)
+
+    # Set the value
+    _set_by_path(user_config, key, parsed_value)
+
+    # Write back
+    _write_config(config_path, user_config)
+
+    if not args.quiet:
+        print(f"Set {key} = {_format_value(parsed_value)}")
+
+    return 0
+
+
+def cmd_unset(args: argparse.Namespace) -> int:
+    """Remove a configuration key."""
+    config_path = _get_config_path(args)
+
+    if not config_path:
+        print("No configuration file found.", file=sys.stderr)
+        return 1
+
+    key = args.key
+    user_config = _load_user_config(config_path)
+
+    if not _unset_by_path(user_config, key):
+        print(f"Key not found: {key}", file=sys.stderr)
+        return 1
+
+    _write_config(config_path, user_config)
+
+    if not args.quiet:
+        print(f"Unset {key}")
+
+    return 0
+
+
+def cmd_add(args: argparse.Namespace) -> int:
+    """Add a value to an array configuration."""
+    config_path = _get_config_path(args)
+
+    if not config_path:
+        config_path = Path.cwd() / ".elspais.toml"
+
+    key = args.key
+    value = _parse_cli_value(args.value)
+
+    user_config = _load_user_config(config_path)
+
+    # Get or create the array
+    current = _get_by_path(user_config, key)
+
+    if current is None:
+        # Check defaults for existing array
+        default_val = _get_by_path(DEFAULT_CONFIG, key)
+        if isinstance(default_val, list):
+            current = list(default_val)  # Copy default
+        else:
+            current = []
+    elif not isinstance(current, list):
+        print(f"Error: {key} is not an array", file=sys.stderr)
+        return 1
+
+    if value in current:
+        print(f"Value already exists in {key}: {_format_value(value)}")
+        return 0
+
+    current.append(value)
+    _set_by_path(user_config, key, current)
+    _write_config(config_path, user_config)
+
+    if not args.quiet:
+        print(f"Added {_format_value(value)} to {key}")
+
+    return 0
+
+
+def cmd_remove(args: argparse.Namespace) -> int:
+    """Remove a value from an array configuration."""
+    config_path = _get_config_path(args)
+
+    if not config_path:
+        print("No configuration file found.", file=sys.stderr)
+        return 1
+
+    key = args.key
+    value = _parse_cli_value(args.value)
+
+    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)
+
+    if current is None or not isinstance(current, list):
+        print(f"Error: {key} is not an array or doesn't exist", file=sys.stderr)
+        return 1
+
+    if value not in current:
+        print(f"Value not in {key}: {_format_value(value)}", file=sys.stderr)
+        return 1
+
+    # Get user config array or copy from defaults
+    user_array = _get_by_path(user_config, key)
+    if user_array is None:
+        user_array = list(current)  # Copy merged
+
+    user_array = [v for v in user_array if v != value]
+    _set_by_path(user_config, key, user_array)
+    _write_config(config_path, user_config)
+
+    if not args.quiet:
+        print(f"Removed {_format_value(value)} from {key}")
+
+    return 0
+
+
+def cmd_path(args: argparse.Namespace) -> int:
+    """Show the path to the configuration file."""
+    config_path = _get_config_path(args)
+
+    if config_path:
+        print(config_path)
+        return 0
+    else:
+        print("No configuration file found.", file=sys.stderr)
+        return 1
+
+
+# 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:
+        return args.config
+    return find_config_file(Path.cwd())
+
+
+def _load_user_config(config_path: Path) -> Dict[str, Any]:
+    """Load user configuration without merging with defaults."""
+    if config_path.exists():
+        return parse_toml(config_path.read_text(encoding="utf-8"))
+    return {}
+
+
+def _get_by_path(config: Dict[str, Any], path: str) -> Any:
+    """Get a value from config using dot-notation path."""
+    parts = path.split(".")
+    current = config
+    for part in parts:
+        if not isinstance(current, dict) or part not in current:
+            return None
+        current = current[part]
+    return current
+
+
+def _set_by_path(config: Dict[str, Any], path: str, value: Any) -> None:
+    """Set a value in config using dot-notation path."""
+    parts = path.split(".")
+    current = config
+    for part in parts[:-1]:
+        if part not in current:
+            current[part] = {}
+        current = current[part]
+    current[parts[-1]] = value
+
+
+def _unset_by_path(config: Dict[str, Any], path: str) -> bool:
+    """Remove a key from config. Returns True if found and removed."""
+    parts = path.split(".")
+    current = config
+    for part in parts[:-1]:
+        if part not in current:
+            return False
+        current = current[part]
+    if parts[-1] in current:
+        del current[parts[-1]]
+        return True
+    return False
+
+
+def _parse_cli_value(value: str) -> Any:
+    """Parse a CLI value string with type inference."""
+    # Boolean
+    if value.lower() == "true":
+        return True
+    if value.lower() == "false":
+        return False
+
+    # Integer
+    try:
+        return int(value)
+    except ValueError:
+        pass
+
+    # Float
+    try:
+        return float(value)
+    except ValueError:
+        pass
+
+    # JSON array or object
+    if value.startswith("[") or value.startswith("{"):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            pass
+
+    # String
+    return value
+
+
+def _format_value(value: Any) -> str:
+    """Format a value for display."""
+    if isinstance(value, str):
+        return f'"{value}"'
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    elif isinstance(value, (list, dict)):
+        return json.dumps(value)
+    else:
+        return str(value)
+
+
+def _print_value(value: Any, prefix: str = "") -> None:
+    """Print a configuration value."""
+    if isinstance(value, dict):
+        for k, v in value.items():
+            key = f"{prefix}.{k}" if prefix else k
+            _print_value(v, key)
+    elif isinstance(value, list):
+        if prefix:
+            print(f"{prefix} = {json.dumps(value)}")
+        else:
+            print(json.dumps(value))
+    elif isinstance(value, bool):
+        if prefix:
+            print(f"{prefix} = {'true' if value else 'false'}")
+        else:
+            print('true' if value else 'false')
+    elif isinstance(value, str):
+        if prefix:
+            print(f'{prefix} = "{value}"')
+        else:
+            print(value)
+    else:
+        if prefix:
+            print(f"{prefix} = {value}")
+        else:
+            print(value)
+
+
+def _print_config(config: Dict[str, Any], indent: int = 0) -> None:
+    """Pretty print configuration in TOML-like format."""
+    for key, value in config.items():
+        if isinstance(value, dict):
+            print(f"\n[{key}]")
+            _print_section(value, key)
+        else:
+            print(f"{key} = {_format_value(value)}")
+
+
+def _print_section(section: Dict[str, Any], path: str, indent: int = 0) -> None:
+    """Print a configuration section."""
+    simple_items = []
+    nested_items = []
+
+    for key, value in section.items():
+        if isinstance(value, dict):
+            nested_items.append((key, value))
+        else:
+            simple_items.append((key, value))
+
+    # Print simple items first
+    for key, value in simple_items:
+        print(f"{key} = {_format_value(value)}")
+
+    # Then nested sections
+    for key, value in nested_items:
+        new_path = f"{path}.{key}"
+        print(f"\n[{new_path}]")
+        _print_section(value, new_path)
+
+
+def _write_config(config_path: Path, config: Dict[str, Any]) -> None:
+    """Write configuration to TOML file."""
+    content = serialize_toml(config)
+    config_path.write_text(content, encoding="utf-8")
+
+
+def serialize_toml(config: Dict[str, Any], prefix: str = "") -> str:
+    """
+    Serialize a dictionary to TOML format.
+
+    Args:
+        config: Configuration dictionary
+        prefix: Section prefix for nested tables
+
+    Returns:
+        TOML formatted string
+    """
+    lines: List[str] = []
+
+    # Separate simple values and nested tables
+    simple_items: List[Tuple[str, Any]] = []
+    nested_items: List[Tuple[str, Dict]] = []
+
+    for key, value in config.items():
+        if isinstance(value, dict) and not _is_inline_table(value):
+            nested_items.append((key, value))
+        else:
+            simple_items.append((key, value))
+
+    # Write simple items
+    for key, value in simple_items:
+        lines.append(f"{key} = {_serialize_value(value)}")
+
+    # Write nested tables
+    for key, value in nested_items:
+        section_name = f"{prefix}.{key}" if prefix else key
+        lines.append("")
+        lines.append(f"[{section_name}]")
+        nested_content = serialize_toml(value, section_name)
+        # Remove leading newline from nested content
+        nested_content = nested_content.lstrip("\n")
+        if nested_content:
+            lines.append(nested_content)
+
+    result = "\n".join(lines)
+    # Clean up multiple consecutive empty lines
+    while "\n\n\n" in result:
+        result = result.replace("\n\n\n", "\n\n")
+    return result
+
+
+def _is_inline_table(value: Dict) -> bool:
+    """Check if a dict should be serialized as inline table."""
+    # Use inline for simple, small tables without nested dicts
+    if len(value) > 4:
+        return False
+    for v in value.values():
+        if isinstance(v, dict):
+            return False
+        if isinstance(v, list) and len(v) > 3:
+            return False
+    return True
+
+
+def _serialize_value(value: Any) -> str:
+    """Serialize a single value to TOML format."""
+    if value is None:
+        return '""'  # TOML doesn't have null, use empty string
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    elif isinstance(value, int):
+        return str(value)
+    elif isinstance(value, float):
+        return str(value)
+    elif isinstance(value, str):
+        # Escape quotes and backslashes
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    elif isinstance(value, list):
+        items = [_serialize_value(v) for v in value]
+        # Check if it fits on one line
+        single_line = f"[{', '.join(items)}]"
+        if len(single_line) < 80:
+            return single_line
+        # Multi-line format
+        return "[\n    " + ",\n    ".join(items) + ",\n]"
+    elif isinstance(value, dict):
+        items = [f"{k} = {_serialize_value(v)}" for k, v in value.items()]
+        return "{ " + ", ".join(items) + " }"
+    else:
+        return str(value)