elspais 0.9.1__py3-none-any.whl → 0.11.0__py3-none-any.whl

elspais/cli.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from typing import List, Optional
 
 from elspais import __version__
-from elspais.commands import analyze, config_cmd, edit, hash_cmd, index, init, rules_cmd, trace, validate
+from elspais.commands import analyze, changed, config_cmd, edit, hash_cmd, index, init, rules_cmd, trace, validate, reformat_cmd
 
 
 def create_parser() -> argparse.ArgumentParser:
@@ -97,6 +97,12 @@ Examples:
         action="store_true",
         help="Skip test scanning",
     )
+    validate_parser.add_argument(
+        "--mode",
+        choices=["core", "combined"],
+        default="combined",
+        help="core: skip sponsor repos, combined: include all (default: combined)",
+    )
 
     # trace command
     trace_parser = subparsers.add_parser(
@@ -115,6 +121,49 @@ Examples:
         help="Output file path",
         metavar="PATH",
     )
+    # trace-view enhanced options (requires elspais[trace-view])
+    trace_parser.add_argument(
+        "--view",
+        action="store_true",
+        help="Generate interactive HTML traceability view (requires trace-view extra)",
+    )
+    trace_parser.add_argument(
+        "--embed-content",
+        action="store_true",
+        help="Embed full requirement content in HTML output",
+    )
+    trace_parser.add_argument(
+        "--edit-mode",
+        action="store_true",
+        help="Include edit mode UI in HTML output",
+    )
+    trace_parser.add_argument(
+        "--review-mode",
+        action="store_true",
+        help="Include review mode UI in HTML output",
+    )
+    trace_parser.add_argument(
+        "--server",
+        action="store_true",
+        help="Start review server (requires trace-review extra)",
+    )
+    trace_parser.add_argument(
+        "--port",
+        type=int,
+        default=8080,
+        help="Port for review server (default: 8080)",
+    )
+    trace_parser.add_argument(
+        "--mode",
+        choices=["core", "sponsor", "combined"],
+        default="core",
+        help="Report mode: core, sponsor, or combined (default: core)",
+    )
+    trace_parser.add_argument(
+        "--sponsor",
+        help="Sponsor name for sponsor-specific reports",
+        metavar="NAME",
+    )
 
     # hash command
     hash_parser = subparsers.add_parser(
@@ -179,6 +228,28 @@ Examples:
         help="Implementation coverage report",
     )
 
+    # changed command
+    changed_parser = subparsers.add_parser(
+        "changed",
+        help="Detect git changes to spec files",
+    )
+    changed_parser.add_argument(
+        "--base-branch",
+        default="main",
+        help="Base branch for comparison (default: main)",
+        metavar="BRANCH",
+    )
+    changed_parser.add_argument(
+        "-j", "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+    changed_parser.add_argument(
+        "-a", "--all",
+        action="store_true",
+        help="Include all changed files (not just spec)",
+    )
+
     # version command
     version_parser = subparsers.add_parser(
         "version",
@@ -371,6 +442,53 @@ Examples:
         help="Content rule file name (e.g., 'AI-AGENT.md')",
     )
 
+    # reformat-with-claude command
+    reformat_parser = subparsers.add_parser(
+        "reformat-with-claude",
+        help="Reformat requirements using AI (Acceptance Criteria -> Assertions)",
+    )
+    reformat_parser.add_argument(
+        "--start-req",
+        help="Starting requirement ID (default: all PRD requirements)",
+        metavar="ID",
+    )
+    reformat_parser.add_argument(
+        "--depth",
+        type=int,
+        help="Maximum traversal depth (default: unlimited)",
+    )
+    reformat_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview changes without applying",
+    )
+    reformat_parser.add_argument(
+        "--backup",
+        action="store_true",
+        help="Create .bak files before editing",
+    )
+    reformat_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Reformat even if already in new format",
+    )
+    reformat_parser.add_argument(
+        "--fix-line-breaks",
+        action="store_true",
+        help="Normalize line breaks (remove extra blank lines)",
+    )
+    reformat_parser.add_argument(
+        "--line-breaks-only",
+        action="store_true",
+        help="Only fix line breaks, skip AI-based reformatting",
+    )
+    reformat_parser.add_argument(
+        "--mode",
+        choices=["combined", "core-only", "local-only"],
+        default="combined",
+        help="Which repos to include in hierarchy (default: combined)",
+    )
+
     # mcp command
     mcp_parser = subparsers.add_parser(
         "mcp",
@@ -455,6 +573,8 @@ def main(argv: Optional[List[str]] = None) -> int:
             return index.run(args)
         elif args.command == "analyze":
             return analyze.run(args)
+        elif args.command == "changed":
+            return changed.run(args)
         elif args.command == "version":
             return version_command(args)
         elif args.command == "init":
@@ -465,6 +585,8 @@ def main(argv: Optional[List[str]] = None) -> int:
             return config_cmd.run(args)
         elif args.command == "rules":
             return rules_cmd.run(args)
+        elif args.command == "reformat-with-claude":
+            return reformat_cmd.run(args)
         elif args.command == "mcp":
             return mcp_command(args)
         else:

elspais/commands/changed.py

@@ -0,0 +1,160 @@
+"""
+elspais.commands.changed - Git-based change detection for requirements.
+
+Detects changes to requirement files using git:
+- Uncommitted changes (modified or new files)
+- Changes vs main/master branch
+- Moved requirements (comparing current location to committed state)
+"""
+
+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,
+    detect_moved_requirements,
+    filter_spec_files,
+    get_current_req_locations,
+    get_git_changes,
+    get_repo_root,
+)
+
+
+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
+
+
+def run(args: argparse.Namespace) -> int:
+    """Run the changed command."""
+    # Get repository root
+    repo_root = get_repo_root()
+    if repo_root is None:
+        print("Error: Not in a git repository")
+        return 1
+
+    # Load config to get spec directory
+    config = load_configuration(args)
+    if config is None:
+        return 1
+
+    spec_dir = config.get("directories", {}).get("spec", "spec")
+    if isinstance(spec_dir, list):
+        spec_dir = spec_dir[0] if spec_dir else "spec"
+
+    base_branch = getattr(args, "base_branch", None) or "main"
+    json_output = getattr(args, "json", False)
+    show_all = getattr(args, "all", False)
+    quiet = getattr(args, "quiet", False)
+
+    # Get git change information
+    changes = get_git_changes(repo_root, spec_dir, base_branch)
+
+    # Filter to spec files only
+    spec_modified = filter_spec_files(changes.modified_files, spec_dir)
+    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
+    )
+
+    # Build result
+    result = {
+        "repo_root": str(repo_root),
+        "spec_dir": spec_dir,
+        "base_branch": base_branch,
+        "uncommitted": {
+            "modified": sorted(spec_modified),
+            "untracked": sorted(spec_untracked),
+            "count": len(spec_modified) + len(spec_untracked),
+        },
+        "branch_changed": {
+            "files": sorted(spec_branch),
+            "count": len(spec_branch),
+        },
+        "moved_requirements": [
+            {
+                "req_id": m.req_id,
+                "old_path": m.old_path,
+                "new_path": m.new_path,
+            }
+            for m in moved
+        ],
+    }
+
+    # Include all files if --all flag is set
+    if show_all:
+        result["all_modified"] = sorted(changes.modified_files)
+        result["all_untracked"] = sorted(changes.untracked_files)
+        result["all_branch_changed"] = sorted(changes.branch_changed_files)
+
+    if json_output:
+        print(json.dumps(result, indent=2))
+        return 0
+
+    # Human-readable output
+    has_changes = False
+
+    if spec_modified or spec_untracked:
+        has_changes = True
+        if not quiet:
+            uncommitted_count = len(spec_modified) + len(spec_untracked)
+            print(f"Uncommitted spec changes: {uncommitted_count}")
+
+            if spec_modified:
+                print(f"  Modified ({len(spec_modified)}):")
+                for f in sorted(spec_modified):
+                    print(f"    M {f}")
+
+            if spec_untracked:
+                print(f"  New ({len(spec_untracked)}):")
+                for f in sorted(spec_untracked):
+                    print(f"    + {f}")
+            print()
+
+    if spec_branch:
+        has_changes = True
+        if not quiet:
+            print(f"Changed vs {base_branch}: {len(spec_branch)}")
+            for f in sorted(spec_branch):
+                print(f"    {f}")
+            print()
+
+    if moved:
+        has_changes = True
+        if not quiet:
+            print(f"Moved requirements: {len(moved)}")
+            for m in moved:
+                print(f"  REQ-{m.req_id}:")
+                print(f"    from: {m.old_path}")
+                print(f"    to:   {m.new_path}")
+            print()
+
+    if not has_changes:
+        if not quiet:
+            print("No uncommitted changes to spec files")
+        return 0
+
+    return 0

elspais/commands/hash_cmd.py

@@ -104,8 +104,16 @@ def run_update(args: argparse.Namespace) -> int:
     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}")
+            result = update_hash_in_file(req, new_hash)
+            if result['updated']:
+                print(f"  ✓ {req_id}")
+                old_hash = result['old_hash'] or "(none)"
+                print(f"    [INFO] Hash: {old_hash} -> {result['new_hash']}")
+                if result['title_fixed']:
+                    print(f"    [INFO] Title fixed: \"{result['old_title']}\" -> \"{req.title}\"")
+            else:
+                print(f"  ✗ {req_id}")
+                print(f"    [WARN] Could not find End marker to update")
 
     return 0
 
@@ -138,37 +146,75 @@ def load_requirements(args: argparse.Namespace) -> tuple:
     return config, requirements
 
 
-def update_hash_in_file(req: Requirement, new_hash: str) -> None:
+def update_hash_in_file(req: Requirement, new_hash: str) -> dict:
     """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.
+    Finds the End marker by the old hash value, then replaces the entire line
+    with the correct title and new hash. This handles cases where the End
+    marker title doesn't match the header title.
+
+    Args:
+        req: Requirement object with file_path, title, and hash
+        new_hash: New hash value to write
+
+    Returns:
+        Dict with change info:
+          - 'updated': bool - whether file was modified
+          - 'old_hash': str - previous hash (or None)
+          - 'new_hash': str - new hash value
+          - 'title_fixed': bool - whether title was corrected
+          - 'old_title': str - previous title (if different)
     """
+    import re
+
+    result = {
+        'updated': False,
+        'old_hash': req.hash,
+        'new_hash': new_hash,
+        'title_fixed': False,
+        'old_title': None,
+    }
+
     if not req.file_path:
-        return
+        return result
 
     content = req.file_path.read_text(encoding="utf-8")
-
-    import re
+    new_end_line = f"*End* *{req.title}* | **Hash**: {new_hash}"
 
     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,
-        )
+        # Strategy: Try title first (most specific), then hash if title not found
+        # This handles both: (1) normal case, (2) mismatched title case
+
+        # First try: match by correct title (handles case where titles match)
+        pattern_by_title = rf"^\*End\*\s+\*{re.escape(req.title)}\*\s*\|\s*\*\*Hash\*\*:\s*[a-fA-F0-9]+\s*$"
+        if re.search(pattern_by_title, content, re.MULTILINE):
+            content, count = re.subn(pattern_by_title, new_end_line, content, flags=re.MULTILINE)
+            if count > 0:
+                result['updated'] = True
+        else:
+            # Second try: find by hash value (handles mismatched title)
+            # Pattern: *End* *AnyTitle* | **Hash**: oldhash
+            pattern_by_hash = rf"^\*End\*\s+\*([^*]+)\*\s*\|\s*\*\*Hash\*\*:\s*{re.escape(req.hash)}\s*$"
+            match = re.search(pattern_by_hash, content, re.MULTILINE)
+
+            if match:
+                old_title = match.group(1)
+                if old_title != req.title:
+                    result['title_fixed'] = True
+                    result['old_title'] = old_title
+
+                # Replace entire line (only first match to avoid affecting other reqs)
+                content = re.sub(pattern_by_hash, new_end_line, content, count=1, flags=re.MULTILINE)
+                result['updated'] = True
     else:
-        # Add hash to end marker
+        # Add hash to end marker (no existing hash)
         # 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")
+        pattern = rf"^(\*End\*\s+\*{re.escape(req.title)}\*)(?!\s*\|\s*\*\*Hash\*\*)\s*$"
+        content, count = re.subn(pattern, new_end_line, content, flags=re.MULTILINE)
+        if count > 0:
+            result['updated'] = True
+
+    if result['updated']:
+        req.file_path.write_text(content, encoding="utf-8")
+
+    return result