elspais 0.9.1__py3-none-any.whl

elspais/commands/edit.py

@@ -0,0 +1,522 @@
+"""
+elspais.commands.edit - Edit requirements command.
+
+Provides functionality to modify requirements in-place:
+- Change Implements references
+- Change Status
+- Move requirements between files
+- Batch operations via JSON
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+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
+
+    # Load configuration
+    config_path = args.config if hasattr(args, 'config') else None
+    if config_path is None:
+        config_path = find_config_file(Path.cwd())
+    if config_path and config_path.exists():
+        config = load_config(config_path)
+    else:
+        config = DEFAULT_CONFIG
+
+    # Get spec directories
+    spec_dir = args.spec_dir if hasattr(args, 'spec_dir') and args.spec_dir else None
+    spec_dirs = get_spec_directories(spec_dir, config)
+    if not spec_dirs:
+        print("Error: No spec directories found", file=sys.stderr)
+        return 1
+
+    # Use first spec dir as base
+    base_spec_dir = spec_dirs[0]
+
+    dry_run = getattr(args, 'dry_run', False)
+
+    validate_refs = getattr(args, 'validate_refs', False)
+
+    # Handle batch mode
+    if hasattr(args, 'from_json') and args.from_json:
+        return run_batch_edit(args.from_json, base_spec_dir, dry_run, validate_refs)
+
+    # Handle single edit mode
+    if hasattr(args, 'req_id') and args.req_id:
+        return run_single_edit(args, base_spec_dir, dry_run)
+
+    print("Error: Must specify --req-id or --from-json", file=sys.stderr)
+    return 1
+
+
+def run_batch_edit(
+    json_source: str, spec_dir: Path, dry_run: bool, validate_refs: bool = False
+) -> int:
+    """Run batch edit from JSON file or stdin."""
+    # Load JSON
+    if json_source == "-":
+        changes = json.load(sys.stdin)
+    else:
+        json_path = Path(json_source)
+        if not json_path.exists():
+            print(f"Error: JSON file not found: {json_source}", file=sys.stderr)
+            return 1
+        changes = json.loads(json_path.read_text())
+
+    if not isinstance(changes, list):
+        print("Error: JSON must be a list of changes", file=sys.stderr)
+        return 1
+
+    results = batch_edit(spec_dir, changes, dry_run=dry_run, validate_refs=validate_refs)
+
+    # Report results
+    success_count = sum(1 for r in results if r.get("success"))
+    error_count = len(results) - success_count
+
+    if dry_run:
+        print(f"[DRY RUN] Would apply {len(results)} changes")
+    else:
+        print(f"Applied {success_count} changes")
+
+    if error_count > 0:
+        print(f"Errors: {error_count}")
+        for r in results:
+            if not r.get("success"):
+                print(f"  - {r.get('req_id', 'unknown')}: {r.get('error', 'unknown error')}")
+        return 1
+
+    return 0
+
+
+def run_single_edit(args: argparse.Namespace, spec_dir: Path, dry_run: bool) -> int:
+    """Run single requirement edit."""
+    req_id = args.req_id
+
+    # Find the requirement
+    location = find_requirement_in_files(spec_dir, req_id)
+    if not location:
+        print(f"Error: Requirement {req_id} not found", file=sys.stderr)
+        return 1
+
+    file_path = location["file_path"]
+    results = []
+
+    # Apply implements change
+    if hasattr(args, 'implements') and args.implements is not None:
+        impl_list = [i.strip() for i in args.implements.split(",")]
+        result = modify_implements(file_path, req_id, impl_list, dry_run=dry_run)
+        results.append(("implements", result))
+
+    # Apply status change
+    if hasattr(args, 'status') and args.status:
+        result = modify_status(file_path, req_id, args.status, dry_run=dry_run)
+        results.append(("status", result))
+
+    # Apply move
+    if hasattr(args, 'move_to') and args.move_to:
+        dest_path = spec_dir / args.move_to
+        result = move_requirement(file_path, dest_path, req_id, dry_run=dry_run)
+        results.append(("move", result))
+
+    # Report
+    for op_name, result in results:
+        # Check for source_empty warning on move
+        if op_name == "move" and result.get("source_empty") and not dry_run:
+            print(f"INFO: Source file is now empty: {result.get('source_file')}")
+        if result.get("success"):
+            if dry_run:
+                print(f"[DRY RUN] Would {op_name}: {req_id}")
+            else:
+                print(f"Updated {op_name}: {req_id}")
+        else:
+            print(f"Error in {op_name}: {result.get('error')}", file=sys.stderr)
+            return 1
+
+    return 0
+
+
+def find_requirement_in_files(
+    spec_dir: Path,
+    req_id: str,
+) -> Optional[Dict[str, Any]]:
+    """
+    Find a requirement in spec files.
+
+    Args:
+        spec_dir: Directory to search
+        req_id: Requirement ID to find
+
+    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)
+
+    for md_file in spec_dir.rglob("*.md"):
+        content = md_file.read_text()
+        match = pattern.search(content)
+        if match:
+            # Count line number
+            line_number = content[:match.start()].count('\n') + 1
+            return {
+                "file_path": md_file,
+                "req_id": req_id,
+                "line_number": line_number,
+            }
+
+    return None
+
+
+def modify_implements(
+    file_path: Path,
+    req_id: str,
+    new_implements: List[str],
+    dry_run: bool = False,
+) -> Dict[str, Any]:
+    """
+    Modify the Implements field of a requirement.
+
+    Args:
+        file_path: Path to the spec file
+        req_id: Requirement ID to modify
+        new_implements: New list of implements references (empty = set to "-")
+        dry_run: If True, don't actually modify the file
+
+    Returns:
+        Dict with success, old_implements, new_implements, error
+    """
+    content = file_path.read_text()
+
+    # Find the requirement header
+    req_pattern = re.compile(rf'^(#\s*{re.escape(req_id)}:[^\n]*\n)', re.MULTILINE)
+    req_match = req_pattern.search(content)
+
+    if not req_match:
+        return {"success": False, "error": f"Requirement {req_id} not found in {file_path}"}
+
+    # Find the **Implements**: field after the header
+    start_pos = req_match.end()
+    search_region = content[start_pos:start_pos + 500]
+
+    impl_pattern = re.compile(r'(\*\*Implements\*\*:\s*)([^|\n]+)')
+    impl_match = impl_pattern.search(search_region)
+
+    if not impl_match:
+        return {"success": False, "error": f"Could not find **Implements** for {req_id}"}
+
+    # Extract old value
+    old_value = impl_match.group(2).strip()
+    old_implements = [v.strip() for v in old_value.split(",")] if old_value != "-" else []
+
+    # Build new value
+    if new_implements:
+        new_value = ", ".join(new_implements)
+    else:
+        new_value = "-"
+
+    # Calculate absolute positions
+    abs_start = start_pos + impl_match.start()
+    abs_end = start_pos + impl_match.end()
+
+    old_line = impl_match.group(0)
+    new_line = impl_match.group(1) + new_value
+
+    if old_line == new_line:
+        return {
+            "success": True,
+            "old_implements": old_implements,
+            "new_implements": new_implements,
+            "no_change": True,
+            "dry_run": dry_run,
+        }
+
+    # Apply change
+    new_content = content[:abs_start] + new_line + content[abs_end:]
+
+    if not dry_run:
+        file_path.write_text(new_content)
+
+    return {
+        "success": True,
+        "old_implements": old_implements,
+        "new_implements": new_implements,
+        "dry_run": dry_run,
+    }
+
+
+def modify_status(
+    file_path: Path,
+    req_id: str,
+    new_status: str,
+    dry_run: bool = False,
+) -> Dict[str, Any]:
+    """
+    Modify the Status field of a requirement.
+
+    Args:
+        file_path: Path to the spec file
+        req_id: Requirement ID to modify
+        new_status: New status value
+        dry_run: If True, don't actually modify the file
+
+    Returns:
+        Dict with success, old_status, new_status, error
+    """
+    content = file_path.read_text()
+
+    # Find the requirement header
+    req_pattern = re.compile(rf'^(#\s*{re.escape(req_id)}:[^\n]*\n)', re.MULTILINE)
+    req_match = req_pattern.search(content)
+
+    if not req_match:
+        return {"success": False, "error": f"Requirement {req_id} not found in {file_path}"}
+
+    # Find the **Status**: field after the header
+    start_pos = req_match.end()
+    search_region = content[start_pos:start_pos + 500]
+
+    status_pattern = re.compile(r'(\*\*Status\*\*:\s*)(\w+)')
+    status_match = status_pattern.search(search_region)
+
+    if not status_match:
+        return {"success": False, "error": f"Could not find **Status** for {req_id}"}
+
+    old_status = status_match.group(2)
+
+    if old_status == new_status:
+        return {
+            "success": True,
+            "old_status": old_status,
+            "new_status": new_status,
+            "no_change": True,
+            "dry_run": dry_run,
+        }
+
+    # Calculate absolute positions
+    abs_start = start_pos + status_match.start()
+    abs_end = start_pos + status_match.end()
+
+    new_line = status_match.group(1) + new_status
+
+    # Apply change
+    new_content = content[:abs_start] + new_line + content[abs_end:]
+
+    if not dry_run:
+        file_path.write_text(new_content)
+
+    return {
+        "success": True,
+        "old_status": old_status,
+        "new_status": new_status,
+        "dry_run": dry_run,
+    }
+
+
+def move_requirement(
+    source_file: Path,
+    dest_file: Path,
+    req_id: str,
+    dry_run: bool = False,
+) -> Dict[str, Any]:
+    """
+    Move a requirement from one file to another.
+
+    Args:
+        source_file: Source spec file
+        dest_file: Destination spec file
+        req_id: Requirement ID to move
+        dry_run: If True, don't actually modify files
+
+    Returns:
+        Dict with success, source_file, dest_file, error
+    """
+    source_content = source_file.read_text()
+
+    # Find the requirement block
+    # 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)?)',
+        re.MULTILINE | re.DOTALL
+    )
+
+    req_match = req_pattern.search(source_content)
+
+    if not req_match:
+        return {"success": False, "error": f"Requirement {req_id} not found in {source_file}"}
+
+    req_block = req_match.group(0)
+
+    # Ensure block ends with separator
+    if not req_block.endswith("---\n"):
+        req_block = req_block.rstrip() + "\n---\n"
+
+    # Remove from source
+    new_source_content = source_content[:req_match.start()] + source_content[req_match.end():]
+    # Clean up extra blank lines
+    new_source_content = re.sub(r'\n{3,}', '\n\n', new_source_content)
+
+    # Add to destination
+    dest_content = dest_file.read_text() if dest_file.exists() else ""
+    if dest_content and not dest_content.endswith("\n"):
+        dest_content += "\n"
+    if dest_content and not dest_content.endswith("\n\n"):
+        dest_content += "\n"
+    new_dest_content = dest_content + req_block
+
+    # Check if source will be empty after move
+    source_empty = len(new_source_content.strip()) == 0
+
+    if not dry_run:
+        source_file.write_text(new_source_content)
+        dest_file.write_text(new_dest_content)
+
+    return {
+        "success": True,
+        "source_file": str(source_file),
+        "dest_file": str(dest_file),
+        "source_empty": source_empty,
+        "dry_run": dry_run,
+    }
+
+
+def collect_all_req_ids(spec_dir: Path) -> set:
+    """
+    Collect all requirement IDs from spec directory.
+
+    Args:
+        spec_dir: Directory to scan
+
+    Returns:
+        Set of requirement IDs found (short form, e.g., "p00001")
+    """
+    import re
+    req_ids = set()
+    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()
+        for match in pattern.finditer(content):
+            full_id = match.group(1)
+            # Extract short form (e.g., "p00001" from "REQ-p00001")
+            if full_id.startswith("REQ-"):
+                short_id = full_id[4:]  # Remove "REQ-" prefix
+                req_ids.add(short_id)
+            req_ids.add(full_id)  # Also add full form
+
+    return req_ids
+
+
+def batch_edit(
+    spec_dir: Path,
+    changes: List[Dict[str, Any]],
+    dry_run: bool = False,
+    validate_refs: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Apply batch edits from a list of change specifications.
+
+    Args:
+        spec_dir: Base spec directory
+        changes: List of change dicts, each with req_id and one of:
+                 - implements: List[str]
+                 - status: str
+                 - move_to: str (relative path)
+        dry_run: If True, don't actually modify files
+        validate_refs: If True, validate that implements references exist
+
+    Returns:
+        List of result dicts
+    """
+    results = []
+
+    # Collect all req IDs if validation is enabled
+    valid_refs: Optional[set] = None
+    if validate_refs:
+        valid_refs = collect_all_req_ids(spec_dir)
+
+    for change in changes:
+        req_id = change.get("req_id")
+        if not req_id:
+            results.append({"success": False, "error": "Missing req_id"})
+            continue
+
+        # Find the requirement
+        location = find_requirement_in_files(spec_dir, req_id)
+        if not location:
+            results.append({
+                "success": False,
+                "req_id": req_id,
+                "error": f"Requirement {req_id} not found",
+            })
+            continue
+
+        file_path = location["file_path"]
+        result: Dict[str, Any] = {"req_id": req_id, "success": True}
+
+        # Validate implements references if enabled
+        if validate_refs and valid_refs and "implements" in change:
+            invalid_refs = []
+            for ref in change["implements"]:
+                # Check both short and full forms
+                if ref not in valid_refs and f"REQ-{ref}" not in valid_refs:
+                    invalid_refs.append(ref)
+            if invalid_refs:
+                result = {
+                    "req_id": req_id,
+                    "success": False,
+                    "error": f"Invalid implements references: {', '.join(invalid_refs)}",
+                }
+                results.append(result)
+                continue
+
+        # Apply implements change
+        if "implements" in change:
+            impl_result = modify_implements(
+                file_path, req_id, change["implements"], dry_run=dry_run
+            )
+            if not impl_result["success"]:
+                result = impl_result
+                result["req_id"] = req_id
+                results.append(result)
+                continue
+            result["implements"] = impl_result
+
+        # Apply status change
+        if "status" in change:
+            status_result = modify_status(
+                file_path, req_id, change["status"], dry_run=dry_run
+            )
+            if not status_result["success"]:
+                result = status_result
+                result["req_id"] = req_id
+                results.append(result)
+                continue
+            result["status"] = status_result
+
+        # Apply move (must be last since it changes file location)
+        if "move_to" in change:
+            dest_path = spec_dir / change["move_to"]
+            move_result = move_requirement(
+                file_path, dest_path, req_id, dry_run=dry_run
+            )
+            if not move_result["success"]:
+                result = move_result
+                result["req_id"] = req_id
+                results.append(result)
+                continue
+            result["move"] = move_result
+
+        result["dry_run"] = dry_run
+        results.append(result)
+
+    return results

elspais/commands/hash_cmd.py

@@ -0,0 +1,174 @@
+"""
+elspais.commands.hash_cmd - Hash management command.
+
+Verify and update requirement hashes.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+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.parser import RequirementParser
+from elspais.core.patterns import PatternConfig
+
+
+def run(args: argparse.Namespace) -> int:
+    """Run the hash command."""
+    if not args.hash_action:
+        print("Usage: elspais hash {verify|update}")
+        return 1
+
+    if args.hash_action == "verify":
+        return run_verify(args)
+    elif args.hash_action == "update":
+        return run_update(args)
+
+    return 1
+
+
+def run_verify(args: argparse.Namespace) -> int:
+    """Verify all requirement hashes."""
+    config, requirements = load_requirements(args)
+    if not requirements:
+        return 1
+
+    hash_length = config.get("validation", {}).get("hash_length", 8)
+    algorithm = config.get("validation", {}).get("hash_algorithm", "sha256")
+
+    mismatches = []
+    missing = []
+
+    for req_id, req in requirements.items():
+        if not req.hash:
+            missing.append(req_id)
+        else:
+            expected = calculate_hash(req.body, length=hash_length, algorithm=algorithm)
+            if not verify_hash(req.body, req.hash, length=hash_length, algorithm=algorithm):
+                mismatches.append((req_id, req.hash, expected))
+
+    # Report results
+    if missing:
+        print(f"Missing hashes: {len(missing)}")
+        for req_id in missing:
+            print(f"  - {req_id}")
+
+    if mismatches:
+        print(f"\nHash mismatches: {len(mismatches)}")
+        for req_id, current, expected in mismatches:
+            print(f"  - {req_id}: {current} (expected: {expected})")
+
+    if not missing and not mismatches:
+        print(f"✓ All {len(requirements)} hashes verified")
+        return 0
+
+    return 1 if mismatches else 0
+
+
+def run_update(args: argparse.Namespace) -> int:
+    """Update requirement hashes."""
+    config, requirements = load_requirements(args)
+    if not requirements:
+        return 1
+
+    hash_length = config.get("validation", {}).get("hash_length", 8)
+    algorithm = config.get("validation", {}).get("hash_algorithm", "sha256")
+
+    # Filter to specific requirement if specified
+    if args.req_id:
+        if args.req_id not in requirements:
+            print(f"Requirement not found: {args.req_id}")
+            return 1
+        requirements = {args.req_id: requirements[args.req_id]}
+
+    updates = []
+
+    for req_id, req in requirements.items():
+        expected = calculate_hash(req.body, length=hash_length, algorithm=algorithm)
+        if req.hash != expected:
+            updates.append((req_id, req, expected))
+
+    if not updates:
+        print("All hashes are up to date")
+        return 0
+
+    # Show or apply updates
+    if args.dry_run:
+        print(f"Would update {len(updates)} hashes:")
+        for req_id, req, new_hash in updates:
+            old_hash = req.hash or "(none)"
+            print(f"  {req_id}: {old_hash} -> {new_hash}")
+    else:
+        print(f"Updating {len(updates)} hashes...")
+        for req_id, req, new_hash in updates:
+            update_hash_in_file(req, new_hash)
+            print(f"  ✓ {req_id}")
+
+    return 0
+
+
+def load_requirements(args: argparse.Namespace) -> tuple:
+    """Load configuration and requirements."""
+    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 config, {}
+
+    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:
+        requirements = parser.parse_directories(spec_dirs, skip_files=skip_files)
+    except Exception as e:
+        print(f"Error parsing requirements: {e}", file=sys.stderr)
+        return config, {}
+
+    return config, requirements
+
+
+def update_hash_in_file(req: Requirement, new_hash: str) -> None:
+    """Update the hash in the requirement's source file.
+
+    The replacement is scoped to the specific requirement's end marker
+    (identified by title) to avoid accidentally updating other requirements
+    in the same file that might have the same hash value.
+    """
+    if not req.file_path:
+        return
+
+    content = req.file_path.read_text(encoding="utf-8")
+
+    import re
+
+    if req.hash:
+        # Replace existing hash - SCOPED to this requirement's end marker
+        # Match: *End* *Title* | **Hash**: oldhash
+        # Replace hash only for THIS requirement (identified by title)
+        content = re.sub(
+            rf"(\*End\*\s+\*{re.escape(req.title)}\*\s*\|\s*)\*\*Hash\*\*:\s*{re.escape(req.hash)}",
+            rf"\1**Hash**: {new_hash}",
+            content,
+        )
+    else:
+        # Add hash to end marker
+        # Pattern: *End* *Title* (without hash)
+        # Add: | **Hash**: XXXX
+        content = re.sub(
+            rf"(\*End\*\s+\*{re.escape(req.title)}\*)(?!\s*\|\s*\*\*Hash\*\*)",
+            rf"\1 | **Hash**: {new_hash}",
+            content,
+        )
+
+    req.file_path.write_text(content, encoding="utf-8")