elspais 0.9.1__py3-none-any.whl

elspais/commands/index.py

@@ -0,0 +1,166 @@
+"""
+elspais.commands.index - INDEX.md management command.
+"""
+
+import argparse
+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.parser import RequirementParser
+from elspais.core.patterns import PatternConfig
+
+
+def run(args: argparse.Namespace) -> int:
+    """Run the index command."""
+    if not args.index_action:
+        print("Usage: elspais index {validate|regenerate}")
+        return 1
+
+    if args.index_action == "validate":
+        return run_validate(args)
+    elif args.index_action == "regenerate":
+        return run_regenerate(args)
+
+    return 1
+
+
+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
+
+    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")
+
+    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)
+
+    # Parse INDEX.md to find listed requirements
+    index_content = index_file.read_text(encoding="utf-8")
+    indexed_ids = set()
+
+    import re
+    for match in re.finditer(r"\|\s*([A-Z]+-(?:[A-Z]+-)?[a-zA-Z]?\d+)\s*\|", index_content):
+        indexed_ids.add(match.group(1))
+
+    # Compare
+    actual_ids = set(requirements.keys())
+    missing = actual_ids - indexed_ids
+    extra = indexed_ids - actual_ids
+
+    if missing:
+        print(f"Missing from INDEX.md ({len(missing)}):")
+        for req_id in sorted(missing):
+            print(f"  - {req_id}")
+
+    if extra:
+        print(f"\nExtra in INDEX.md ({len(extra)}):")
+        for req_id in sorted(extra):
+            print(f"  - {req_id}")
+
+    if not missing and not extra:
+        print(f"✓ INDEX.md is accurate ({len(actual_ids)} requirements)")
+        return 0
+
+    return 1
+
+
+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
+
+    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
+
+    # Generate INDEX.md
+    content = generate_index(requirements, config)
+    index_file.write_text(content, encoding="utf-8")
+
+    print(f"Regenerated: {index_file}")
+    print(f"  {len(requirements)} requirements indexed")
+
+    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:
+            continue
+
+        lines.append(f"## {title}")
+        lines.append("")
+        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} |")
+
+        lines.append("")
+
+    lines.extend([
+        "---",
+        "",
+        "*Generated by elspais*",
+    ])
+
+    return "\n".join(lines)
+
+

elspais/commands/init.py

@@ -0,0 +1,177 @@
+"""
+elspais.commands.init - Initialize configuration command.
+
+Creates .elspais.toml configuration file.
+"""
+
+import argparse
+from pathlib import Path
+from typing import Optional
+
+
+def run(args: argparse.Namespace) -> int:
+    """
+    Run the init command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success)
+    """
+    config_path = Path.cwd() / ".elspais.toml"
+
+    if config_path.exists() and not args.force:
+        print(f"Configuration file already exists: {config_path}")
+        print("Use --force to overwrite.")
+        return 1
+
+    # Determine project type
+    project_type = args.type or "core"
+    associated_prefix = args.associated_prefix
+
+    if project_type == "associated" and not associated_prefix:
+        print("Error: --associated-prefix required for associated repositories")
+        return 1
+
+    # Generate configuration
+    config_content = generate_config(project_type, associated_prefix)
+
+    # Write file
+    config_path.write_text(config_content)
+    print(f"Created configuration: {config_path}")
+
+    return 0
+
+
+def generate_config(project_type: str, associated_prefix: Optional[str] = None) -> str:
+    """Generate configuration file content."""
+
+    if project_type == "associated":
+        if associated_prefix is None:
+            associated_prefix = "XXX"  # Placeholder if not provided
+        return f'''# elspais configuration - Associated Repository
+# Generated by: elspais init --type associated
+
+[project]
+name = "{associated_prefix.lower()}-project"
+type = "associated"
+
+[associated]
+prefix = "{associated_prefix}"
+id_range = [1, 99999]
+
+[core]
+# Path to core repository (relative or absolute)
+path = "../core"
+
+[directories]
+spec = "spec"
+docs = "docs"
+code = ["src", "lib"]
+
+[patterns]
+id_template = "{{prefix}}-{{associated}}{{type}}{{id}}"
+prefix = "REQ"
+
+[patterns.types]
+prd = {{ id = "p", name = "Product Requirement", level = 1 }}
+ops = {{ id = "o", name = "Operations Requirement", level = 2 }}
+dev = {{ id = "d", name = "Development Requirement", level = 3 }}
+
+[patterns.id_format]
+style = "numeric"
+digits = 5
+leading_zeros = true
+
+[patterns.associated]
+enabled = true
+length = 3
+format = "uppercase"
+separator = "-"
+
+[rules.hierarchy]
+allowed_implements = [
+    "dev -> ops, prd",
+    "ops -> prd",
+    "prd -> prd",
+]
+cross_repo_implements = true
+allow_orphans = true  # More permissive for associated development
+
+[rules.format]
+require_hash = true
+require_assertions = true
+'''
+
+    else:  # core
+        return '''# elspais configuration - Core Repository
+# Generated by: elspais init
+
+[project]
+name = "my-project"
+type = "core"
+
+[directories]
+spec = "spec"
+docs = "docs"
+database = "database"
+code = ["src", "apps", "packages"]
+
+[patterns]
+id_template = "{prefix}-{type}{id}"
+prefix = "REQ"
+
+[patterns.types]
+prd = { id = "p", name = "Product Requirement", level = 1 }
+ops = { id = "o", name = "Operations Requirement", level = 2 }
+dev = { id = "d", name = "Development Requirement", level = 3 }
+
+[patterns.id_format]
+style = "numeric"
+digits = 5
+leading_zeros = true
+
+[patterns.associated]
+enabled = true
+length = 3
+format = "uppercase"
+separator = "-"
+
+[spec]
+index_file = "INDEX.md"
+skip_files = ["README.md", "requirements-format.md", "INDEX.md"]
+
+[spec.file_patterns]
+"prd-*.md" = "prd"
+"ops-*.md" = "ops"
+"dev-*.md" = "dev"
+
+[rules.hierarchy]
+allowed_implements = [
+    "dev -> ops, prd",
+    "ops -> prd",
+    "prd -> prd",
+]
+allow_circular = false
+allow_orphans = false
+
+[rules.format]
+require_hash = true
+require_rationale = false
+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",
+]
+'''

elspais/commands/rules_cmd.py

@@ -0,0 +1,120 @@
+"""
+elspais.commands.rules_cmd - Content rules management command.
+
+View and manage content rule files.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional
+
+from elspais.config.loader import find_config_file, load_config
+from elspais.core.content_rules import load_content_rules, load_content_rule
+
+
+def run(args: argparse.Namespace) -> int:
+    """
+    Run the rules command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success)
+    """
+    action = getattr(args, "rules_action", None)
+
+    if action == "list":
+        return cmd_list(args)
+    elif action == "show":
+        return cmd_show(args)
+    else:
+        # Default to list
+        return cmd_list(args)
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    """List configured content rules."""
+    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)
+    base_path = config_path.parent
+
+    rules = load_content_rules(config, base_path)
+
+    if not rules:
+        print("No content rules configured.")
+        print("\nTo add content rules, use:")
+        print('  elspais config add rules.content_rules "spec/AI-AGENT.md"')
+        return 0
+
+    print("Content Rules:")
+    print("-" * 60)
+    for rule in rules:
+        rel_path = rule.file_path.relative_to(base_path) if base_path in rule.file_path.parents else rule.file_path
+        print(f"  {rel_path}")
+        print(f"    Title: {rule.title}")
+        print(f"    Type: {rule.type}")
+        if rule.applies_to:
+            print(f"    Applies to: {', '.join(rule.applies_to)}")
+        print()
+
+    return 0
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    """Show content of a specific content rule."""
+    config_path = _get_config_path(args)
+    file_name = args.file
+
+    if not config_path:
+        print("No configuration file found.", file=sys.stderr)
+        return 1
+
+    config = load_config(config_path)
+    base_path = config_path.parent
+
+    # Load all rules and find the matching one
+    rules = load_content_rules(config, base_path)
+
+    matching_rule = None
+    for rule in rules:
+        if rule.file_path.name == file_name or str(rule.file_path).endswith(file_name):
+            matching_rule = rule
+            break
+
+    # If not in config, try loading directly
+    if not matching_rule:
+        file_path = base_path / file_name
+        if file_path.exists():
+            try:
+                matching_rule = load_content_rule(file_path)
+            except Exception as e:
+                print(f"Error loading file: {e}", file=sys.stderr)
+                return 1
+        else:
+            print(f"Content rule not found: {file_name}", file=sys.stderr)
+            return 1
+
+    # Display the rule
+    print(f"# {matching_rule.title}")
+    print(f"Type: {matching_rule.type}")
+    if matching_rule.applies_to:
+        print(f"Applies to: {', '.join(matching_rule.applies_to)}")
+    print(f"File: {matching_rule.file_path}")
+    print("-" * 60)
+    print(matching_rule.content)
+
+    return 0
+
+
+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())

elspais/commands/trace.py

@@ -0,0 +1,208 @@
+"""
+elspais.commands.trace - Generate traceability matrix command.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+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 trace command."""
+    # Load configuration
+    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
+
+    # Get spec directories
+    spec_dirs = get_spec_directories(args.spec_dir, config)
+    if not spec_dirs:
+        print("Error: No spec directories found", file=sys.stderr)
+        return 1
+
+    # Parse requirements
+    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)
+    requirements = parser.parse_directories(spec_dirs, skip_files=skip_files)
+
+    if not requirements:
+        print("No requirements found.")
+        return 1
+
+    # Determine output format
+    output_format = args.format
+
+    # Generate output
+    if output_format in ["markdown", "both"]:
+        md_output = generate_markdown_matrix(requirements)
+        if args.output:
+            if output_format == "markdown":
+                output_path = args.output
+            else:
+                output_path = args.output.with_suffix(".md")
+        else:
+            output_path = Path("traceability.md")
+        output_path.write_text(md_output)
+        print(f"Generated: {output_path}")
+
+    if output_format in ["html", "both"]:
+        html_output = generate_html_matrix(requirements)
+        if args.output:
+            if output_format == "html":
+                output_path = args.output
+            else:
+                output_path = args.output.with_suffix(".html")
+        else:
+            output_path = Path("traceability.html")
+        output_path.write_text(html_output)
+        print(f"Generated: {output_path}")
+
+    if output_format == "csv":
+        csv_output = generate_csv_matrix(requirements)
+        output_path = args.output or Path("traceability.csv")
+        output_path.write_text(csv_output)
+        print(f"Generated: {output_path}")
+
+    return 0
+
+
+def generate_markdown_matrix(requirements: Dict[str, Requirement]) -> str:
+    """Generate Markdown traceability matrix."""
+    lines = ["# Traceability Matrix", "", "## Requirements Hierarchy", ""]
+
+    # 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"]}
+
+    # PRD table
+    if prd_reqs:
+        lines.extend(["### Product Requirements", ""])
+        lines.append("| ID | Title | Status | Implemented By |")
+        lines.append("|---|---|---|---|")
+        for req_id, req in sorted(prd_reqs.items()):
+            impl_by = find_implementers(req_id, requirements)
+            impl_str = ", ".join(impl_by) if impl_by else "-"
+            lines.append(f"| {req_id} | {req.title} | {req.status} | {impl_str} |")
+        lines.append("")
+
+    # OPS table
+    if ops_reqs:
+        lines.extend(["### Operations Requirements", ""])
+        lines.append("| ID | Title | Implements | Status |")
+        lines.append("|---|---|---|---|")
+        for req_id, req in sorted(ops_reqs.items()):
+            impl_str = ", ".join(req.implements) if req.implements else "-"
+            lines.append(f"| {req_id} | {req.title} | {impl_str} | {req.status} |")
+        lines.append("")
+
+    # DEV table
+    if dev_reqs:
+        lines.extend(["### Development Requirements", ""])
+        lines.append("| ID | Title | Implements | Status |")
+        lines.append("|---|---|---|---|")
+        for req_id, req in sorted(dev_reqs.items()):
+            impl_str = ", ".join(req.implements) if req.implements else "-"
+            lines.append(f"| {req_id} | {req.title} | {impl_str} | {req.status} |")
+        lines.append("")
+
+    lines.extend(["---", "*Generated by elspais*"])
+    return "\n".join(lines)
+
+
+def generate_html_matrix(requirements: Dict[str, Requirement]) -> str:
+    """Generate HTML traceability matrix."""
+    html = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Traceability Matrix</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; margin: 2rem; }
+        h1 { color: #333; }
+        table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
+        th, td { border: 1px solid #ddd; padding: 0.5rem; text-align: left; }
+        th { background: #f5f5f5; }
+        tr:hover { background: #f9f9f9; }
+        .status-active { color: green; }
+        .status-draft { color: orange; }
+        .status-deprecated { color: red; }
+    </style>
+</head>
+<body>
+    <h1>Traceability Matrix</h1>
+"""
+
+    # 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_reqs),
+        ("Operations Requirements", ops_reqs),
+        ("Development Requirements", dev_reqs),
+    ]:
+        if not reqs:
+            continue
+
+        html += f"    <h2>{title}</h2>\n"
+        html += "    <table>\n"
+        html += "        <tr><th>ID</th><th>Title</th><th>Implements</th><th>Status</th></tr>\n"
+
+        for req_id, req in sorted(reqs.items()):
+            impl_str = ", ".join(req.implements) if req.implements else "-"
+            status_class = f"status-{req.status.lower()}"
+            subdir_attr = f'data-subdir="{req.subdir}"'
+            html += (
+                f'        <tr {subdir_attr}><td>{req_id}</td><td>{req.title}</td>'
+                f'<td>{impl_str}</td><td class="{status_class}">{req.status}</td></tr>\n'
+            )
+
+        html += "    </table>\n"
+
+    html += """    <hr>
+    <p><em>Generated by elspais</em></p>
+</body>
+</html>"""
+    return html
+
+
+def generate_csv_matrix(requirements: Dict[str, Requirement]) -> str:
+    """Generate CSV traceability matrix."""
+    lines = ["ID,Title,Level,Status,Implements,Subdir"]
+
+    for req_id, req in sorted(requirements.items()):
+        impl_str = ";".join(req.implements) if req.implements else ""
+        title = req.title.replace('"', '""')
+        lines.append(f'"{req_id}","{title}","{req.level}","{req.status}","{impl_str}","{req.subdir}"')
+
+    return "\n".join(lines)
+
+
+def find_implementers(req_id: str, requirements: Dict[str, Requirement]) -> List[str]:
+    """Find requirements that implement the given requirement."""
+    implementers = []
+    short_id = req_id.split("-")[-1] if "-" in req_id else req_id
+
+    for other_id, other_req in requirements.items():
+        for impl in other_req.implements:
+            if impl == req_id or impl == short_id or impl.endswith(short_id):
+                implementers.append(other_id)
+                break
+
+    return implementers
+
+