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

elspais/commands/index.py

@@ -1,147 +1,124 @@
+# Implements: REQ-int-d00003 (CLI Extension)
 """
 elspais.commands.index - INDEX.md management command.
+
+Uses graph-based system:
+- `elspais index validate` - Validate INDEX.md accuracy
+- `elspais index regenerate` - Regenerate INDEX.md from requirements
 """
 
+from __future__ import annotations
+
 import argparse
+import re
+import sys
 from pathlib import Path
+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.parser import RequirementParser
-from elspais.core.patterns import PatternConfig
+from elspais.graph import NodeKind
 
 
 def run(args: argparse.Namespace) -> int:
     """Run the index command."""
-    if not args.index_action:
-        print("Usage: elspais index {validate|regenerate}")
-        return 1
+    from elspais.config import get_config, get_spec_directories
+    from elspais.graph.factory import build_graph
 
-    if args.index_action == "validate":
-        return run_validate(args)
-    elif args.index_action == "regenerate":
-        return run_regenerate(args)
+    spec_dir = getattr(args, "spec_dir", None)
+    config_path = getattr(args, "config", None)
 
-    return 1
+    config = get_config(config_path)
+    spec_dirs = get_spec_directories(spec_dir, config)
 
+    graph = build_graph(
+        config=config,
+        spec_dirs=spec_dirs if spec_dir else None,
+        config_path=config_path,
+    )
 
-def run_validate(args: argparse.Namespace) -> int:
-    """Validate INDEX.md accuracy."""
-    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
+    action = getattr(args, "index_action", None)
 
-    spec_dirs = get_spec_directories(args.spec_dir, config)
-    if not spec_dirs:
-        print("Error: No spec directories found")
+    if action == "validate":
+        return _validate_index(graph, spec_dirs, args)
+    elif action == "regenerate":
+        return _regenerate_index(graph, spec_dirs, args)
+    else:
+        print("Usage: elspais index <validate|regenerate>", file=sys.stderr)
         return 1
 
-    spec_config = config.get("spec", {})
-    # Use first spec directory for INDEX.md location
-    index_file = spec_dirs[0] / spec_config.get("index_file", "INDEX.md")
-
-    if not index_file.exists():
-        print(f"INDEX.md not found: {index_file}")
-        return 1
 
-    # Parse all requirements
-    pattern_config = PatternConfig.from_dict(config.get("patterns", {}))
-    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)
-    requirements = parser.parse_directories(spec_dirs, skip_files=skip_files)
+def _validate_index(graph: TraceGraph, spec_dirs: list[Path], args: argparse.Namespace) -> int:
+    """Validate INDEX.md against graph requirements."""
+    # Find INDEX.md
+    index_path = None
+    for spec_dir in spec_dirs:
+        candidate = spec_dir / "INDEX.md"
+        if candidate.exists():
+            index_path = candidate
+            break
 
-    # Parse INDEX.md to find listed requirements
-    index_content = index_file.read_text(encoding="utf-8")
-    indexed_ids = set()
+    if not index_path:
+        print("No INDEX.md found in spec directories.")
+        print("Run 'elspais index regenerate' to create one.")
+        return 1
 
-    import re
+    # Parse IDs from INDEX.md
+    content = index_path.read_text()
+    index_ids = set(re.findall(r"REQ-[a-z0-9-]+", content, re.IGNORECASE))
 
-    for match in re.finditer(r"\|\s*([A-Z]+-(?:[A-Z]+-)?[a-zA-Z]?\d+)\s*\|", index_content):
-        indexed_ids.add(match.group(1))
+    # Get IDs from graph
+    graph_ids = set()
+    for node in graph.nodes_by_kind(NodeKind.REQUIREMENT):
+        graph_ids.add(node.id)
 
     # Compare
-    actual_ids = set(requirements.keys())
-    missing = actual_ids - indexed_ids
-    extra = indexed_ids - actual_ids
+    missing = graph_ids - index_ids
+    extra = index_ids - graph_ids
 
     if missing:
         print(f"Missing from INDEX.md ({len(missing)}):")
         for req_id in sorted(missing):
-            print(f"  - {req_id}")
+            print(f"  {req_id}")
 
     if extra:
-        print(f"\nExtra in INDEX.md ({len(extra)}):")
+        print(f"Extra in INDEX.md ({len(extra)}):")
         for req_id in sorted(extra):
-            print(f"  - {req_id}")
+            print(f"  {req_id}")
 
     if not missing and not extra:
-        print(f"✓ INDEX.md is accurate ({len(actual_ids)} requirements)")
+        print(f"INDEX.md is up to date ({len(graph_ids)} requirements)")
         return 0
 
-    return 1
+    return 1 if missing or extra else 0
 
 
-def run_regenerate(args: argparse.Namespace) -> int:
-    """Regenerate INDEX.md from 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
+def _regenerate_index(graph: TraceGraph, spec_dirs: list[Path], args: argparse.Namespace) -> int:
+    """Regenerate INDEX.md from graph requirements."""
+    # Group by level
+    by_level = {"PRD": [], "OPS": [], "DEV": [], "other": []}
 
-    spec_dirs = get_spec_directories(args.spec_dir, config)
-    if not spec_dirs:
-        print("Error: No spec directories found")
-        return 1
-
-    spec_config = config.get("spec", {})
-    # Use first spec directory for INDEX.md location
-    index_file = spec_dirs[0] / spec_config.get("index_file", "INDEX.md")
-
-    # Parse all requirements
-    pattern_config = PatternConfig.from_dict(config.get("patterns", {}))
-    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)
-    requirements = parser.parse_directories(spec_dirs, skip_files=skip_files)
-
-    if not requirements:
-        print("No requirements found")
-        return 1
+    for node in graph.nodes_by_kind(NodeKind.REQUIREMENT):
+        level = (node.level or "").upper()
+        if level in by_level:
+            by_level[level].append(node)
+        else:
+            by_level["other"].append(node)
 
-    # Generate INDEX.md
-    content = generate_index(requirements, config)
-    index_file.write_text(content, encoding="utf-8")
+    # Generate markdown
+    lines = ["# Requirements Index", ""]
 
-    print(f"Regenerated: {index_file}")
-    print(f"  {len(requirements)} requirements indexed")
+    level_names = {
+        "PRD": "Product Requirements (PRD)",
+        "OPS": "Operations Requirements (OPS)",
+        "DEV": "Development Requirements (DEV)",
+        "other": "Other Requirements",
+    }
 
-    return 0
-
-
-def generate_index(requirements: dict, config: dict) -> str:
-    """Generate INDEX.md content."""
-    lines = [
-        "# Requirements Index",
-        "",
-        "This file provides a complete index of all requirements.",
-        "",
-    ]
-
-    # Group by type
-    prd_reqs = {k: v for k, v in requirements.items() if v.level.upper() in ["PRD", "PRODUCT"]}
-    ops_reqs = {k: v for k, v in requirements.items() if v.level.upper() in ["OPS", "OPERATIONS"]}
-    dev_reqs = {k: v for k, v in requirements.items() if v.level.upper() in ["DEV", "DEVELOPMENT"]}
-
-    for title, reqs in [
-        ("Product Requirements (PRD)", prd_reqs),
-        ("Operations Requirements (OPS)", ops_reqs),
-        ("Development Requirements (DEV)", dev_reqs),
-    ]:
-        if not reqs:
+    for level, title in level_names.items():
+        nodes = by_level[level]
+        if not nodes:
             continue
 
         lines.append(f"## {title}")
@@ -149,19 +126,25 @@ def generate_index(requirements: dict, config: dict) -> str:
         lines.append("| ID | Title | File | Hash |")
         lines.append("|---|---|---|---|")
 
-        for req_id, req in sorted(reqs.items()):
-            file_name = req.file_path.name if req.file_path else "-"
-            hash_val = req.hash or "-"
-            lines.append(f"| {req_id} | {req.title} | {file_name} | {hash_val} |")
+        for node in sorted(nodes, key=lambda n: n.id):
+            file_path = node.source.path if node.source else ""
+            # Make path relative
+            if file_path:
+                for spec_dir in spec_dirs:
+                    try:
+                        file_path = Path(file_path).relative_to(spec_dir)
+                        break
+                    except ValueError:
+                        pass
+            hash_val = node.hash or ""
+            lines.append(f"| {node.id} | {node.get_label()} | {file_path} | {hash_val} |")
 
         lines.append("")
 
-    lines.extend(
-        [
-            "---",
-            "",
-            "*Generated by elspais*",
-        ]
-    )
+    # Write to first spec dir
+    output_path = spec_dirs[0] / "INDEX.md" if spec_dirs else Path("spec/INDEX.md")
+    output_path.write_text("\n".join(lines))
 
-    return "\n".join(lines)
+    req_count = sum(len(nodes) for nodes in by_level.values())
+    print(f"Generated {output_path} ({req_count} requirements)")
+    return 0

elspais/commands/init.py

@@ -8,6 +8,36 @@ import argparse
 from pathlib import Path
 from typing import Optional
 
+# Example requirement template for --template flag
+EXAMPLE_REQUIREMENT = """# REQ-d00001: Example Requirement Title
+
+**Level**: Dev | **Status**: Draft | **Implements**: -
+
+## Assertions
+
+A. The system SHALL demonstrate the assertion format.
+B. The system SHALL show proper use of SHALL language.
+
+## Rationale
+
+This is an example requirement demonstrating the proper format.
+Delete this file after reviewing the structure.
+
+---
+
+**Format Notes** (delete this section):
+
+- **Title line**: `# REQ-{type}{id}: Title` where type is p/o/d for PRD/OPS/DEV
+- **Metadata line**: Level, Status, and Implements (use `-` for top-level reqs)
+- **Assertions**: Labeled A-Z, each using SHALL for required behavior
+- **Rationale**: Optional explanation section (non-normative)
+- **Footer**: `*End* *Title* | **Hash**: XXXXXXXX` - hash computed by `elspais hash update`
+
+Run `elspais format` for more templates and `elspais validate` to check this file.
+
+*End* *Example Requirement Title* | **Hash**: 00000000
+"""
+
 
 def run(args: argparse.Namespace) -> int:
     """
@@ -19,6 +49,10 @@ def run(args: argparse.Namespace) -> int:
     Returns:
         Exit code (0 for success)
     """
+    # Handle --template flag separately
+    if getattr(args, "template", False):
+        return create_template_requirement(args)
+
     config_path = Path.cwd() / ".elspais.toml"
 
     if config_path.exists() and not args.force:
@@ -44,6 +78,44 @@ def run(args: argparse.Namespace) -> int:
     return 0
 
 
+def create_template_requirement(args: argparse.Namespace) -> int:
+    """Create an example requirement file in the spec directory."""
+    from elspais.config import load_config
+
+    # Try to load config to find spec directory
+    try:
+        config = load_config(args.config if hasattr(args, "config") else None)
+        spec_dir_name = config.get("directories", {}).get("spec", "spec")
+    except Exception:
+        spec_dir_name = "spec"
+
+    spec_dir = Path.cwd() / spec_dir_name
+
+    # Create spec directory if it doesn't exist
+    if not spec_dir.exists():
+        spec_dir.mkdir(parents=True)
+        print(f"Created directory: {spec_dir}")
+
+    # Create example file
+    example_path = spec_dir / "EXAMPLE-requirement.md"
+
+    if example_path.exists() and not getattr(args, "force", False):
+        print(f"Example file already exists: {example_path}")
+        print("Use --force to overwrite.")
+        return 1
+
+    example_path.write_text(EXAMPLE_REQUIREMENT)
+    print(f"Created example requirement: {example_path}")
+    print()
+    print("Next steps:")
+    print("  1. Review the example to understand the format")
+    print("  2. Delete or rename it when creating real requirements")
+    print("  3. Run `elspais validate` to check format compliance")
+    print("  4. Run `elspais hash update` to compute content hashes")
+
+    return 0
+
+
 def generate_config(project_type: str, associated_prefix: Optional[str] = None) -> str:
     """Generate configuration file content."""
 
@@ -91,11 +163,9 @@ format = "uppercase"
 separator = "-"
 
 [rules.hierarchy]
-allowed_implements = [
-    "dev -> ops, prd",
-    "ops -> prd",
-    "prd -> prd",
-]
+dev = ["dev", "ops", "prd"]
+ops = ["ops", "prd"]
+prd = ["prd"]
 cross_repo_implements = true
 allow_orphans = true  # More permissive for associated development
 
@@ -115,7 +185,6 @@ type = "core"
 [directories]
 spec = "spec"
 docs = "docs"
-database = "database"
 code = ["src", "apps", "packages"]
 
 [patterns]
@@ -138,6 +207,11 @@ length = 3
 format = "uppercase"
 separator = "-"
 
+[patterns.assertions]
+label_style = "uppercase"  # "uppercase" | "numeric" | "alphanumeric" | "numeric_1based"
+# max_count = 26           # Defaults to style maximum (26 for uppercase, 100 for numeric)
+# zero_pad = false         # For numeric styles: "01" vs "1"
+
 [spec]
 index_file = "INDEX.md"
 skip_files = ["README.md", "requirements-format.md", "INDEX.md"]
@@ -148,11 +222,9 @@ skip_files = ["README.md", "requirements-format.md", "INDEX.md"]
 "dev-*.md" = "dev"
 
 [rules.hierarchy]
-allowed_implements = [
-    "dev -> ops, prd",
-    "ops -> prd",
-    "prd -> prd",
-]
+dev = ["dev", "ops", "prd"]
+ops = ["ops", "prd"]
+prd = ["prd"]
 allow_circular = false
 allow_orphans = false
 
@@ -163,15 +235,20 @@ require_assertions = true
 require_status = true
 allowed_statuses = ["Active", "Draft", "Deprecated", "Superseded"]
 
-[validation]
-hash_algorithm = "sha256"
-hash_length = 8
-
-[traceability]
-output_formats = ["markdown", "html"]
-scan_patterns = [
-    "database/**/*.sql",
-    "src/**/*.py",
-    "apps/**/*.dart",
-]
+[testing]
+enabled = false
+test_dirs = ["tests"]
+patterns = ["test_*.py", "*_test.py"]
+# result_files = ["test-results.xml"]  # Uncomment to enable test result parsing
+reference_keyword = "Validates"
+
+[ignore]
+# Global patterns applied everywhere
+global = ["node_modules", ".git", "__pycache__", "*.pyc", ".venv", ".env"]
+# Additional patterns for spec file scanning
+spec = ["README.md", "INDEX.md", "drafts/**"]
+# Additional patterns for code scanning
+code = ["*_test.py", "conftest.py", "test_*.py"]
+# Additional patterns for test scanning
+test = ["fixtures/**", "__snapshots__"]
 """