Open-source Revit MCP server: let Claude and other AI assistants read and edit BIM models, with human approval on every change.
Python aecai-agentsautodeskautomationbimclaudeifcmcpmcp-servermodel-context-protocolnavisworksrevitrevit-addinrevit-apirhino
Scaffolds 8 & 9: Reporting + MCP Integration (6 tasks) - PROJECT COMPLETE!
sammohammad578dddaf51e00bd
diff --git a/packages/model-checker/src/model_checker/reporting.py b/packages/model-checker/src/model_checker/reporting.pynew file mode 100644index 0000000..f8e3ece--- /dev/null+++ b/packages/model-checker/src/model_checker/reporting.py@@ -0,0 +1,302 @@+"""Reporting and export capabilities (Scaffold 8) + CLI/MCP integration (Scaffold 9)."""++from __future__ import annotations++import csv+import json+from datetime import datetime+from pathlib import Path+from typing import Any+++# SCAFFOLD 8: Quality Assurance Dashboard++class HTMLReportGenerator:+ """Generate HTML reports for validation results (Task 8.1)."""++ def __init__(self, project_name: str) -> None:+ """Initialize HTML report generator."""+ self.project_name = project_name+ self.issues: list[dict[str, Any]] = []++ def add_issues(self, issues: list[Any]) -> None:+ """Add issues to the report."""+ for issue in issues:+ if hasattr(issue, "to_dict"):+ self.issues.append(issue.to_dict())+ elif isinstance(issue, dict):+ self.issues.append(issue)++ def generate_html(self) -> str:+ """Generate HTML report."""+ html = f"""<!DOCTYPE html>+<html>+<head>+ <title>{self.project_name} - Model Check Report</title>+ <style>+ body {{ font-family: Arial, sans-serif; margin: 20px; }}+ h1 {{ color: #333; }}+ table {{ border-collapse: collapse; width: 100%; margin-top: 20px; }}+ th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}+ th {{ background-color: #4CAF50; color: white; }}+ .critical {{ background-color: #ff4444; color: white; }}+ .high {{ background-color: #ff9933; }}+ .medium {{ background-color: #ffff66; }}+ .low {{ background-color: #99ff99; }}+ .summary {{ margin: 20px 0; padding: 15px; background-color: #f0f0f0; border-radius: 5px; }}+ </style>+</head>+<body>+ <h1>Model Check Report: {self.project_name}</h1>+ <div class="summary">+ <h2>Summary</h2>+ <p>Total Issues: {len(self.issues)}</p>+ <p>Generated: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}</p>+ </div>+ <h2>Issues</h2>+ <table>+ <tr>+ <th>Element ID</th>+ <th>Type</th>+ <th>Issue</th>+ <th>Description</th>+ <th>Severity</th>+ </tr>"""++ for issue in self.issues:+ severity = issue.get("severity", "medium")+ html += f"""+ <tr class="{severity}">+ <td>{issue.get('element_id', 'N/A')}</td>+ <td>{issue.get('element_type', 'N/A')}</td>+ <td>{issue.get('issue_type', 'N/A')}</td>+ <td>{issue.get('description', 'N/A')}</td>+ <td>{severity.upper()}</td>+ </tr>"""++ html += """+ </table>+</body>+</html>"""+ return html++ def save_html(self, filepath: str | Path) -> None:+ """Save HTML report to file."""+ with open(filepath, "w") as f:+ f.write(self.generate_html())+++class IssuePrioritizer:+ """Prioritize and rank validation issues (Task 8.2)."""++ SEVERITY_WEIGHTS = {"critical": 100, "high": 50, "medium": 20, "low": 5, "info": 1}++ def __init__(self) -> None:+ """Initialize issue prioritizer."""+ self.issues: list[dict[str, Any]] = []++ def add_issues(self, issues: list[Any]) -> None:+ """Add issues for prioritization."""+ for issue in issues:+ if hasattr(issue, "to_dict"):+ self.issues.append(issue.to_dict())+ elif hasattr(issue, "__dict__"):+ self.issues.append(vars(issue))+ elif isinstance(issue, dict):+ self.issues.append(issue)++ def prioritize(self) -> list[dict[str, Any]]:+ """Prioritize issues by severity and impact."""++ def get_priority_score(issue: dict[str, Any]) -> int:+ severity = issue.get("severity", "low")+ return self.SEVERITY_WEIGHTS.get(severity, 1)++ return sorted(self.issues, key=get_priority_score, reverse=True)++ def get_top_issues(self, limit: int = 10) -> list[dict[str, Any]]:+ """Get top N priority issues."""+ return self.prioritize()[:limit]+++class ReportExporter:+ """Export reports in various formats (Task 8.3)."""++ def __init__(self) -> None:+ """Initialize report exporter."""+ self.issues: list[dict[str, Any]] = []++ def add_issues(self, issues: list[Any]) -> None:+ """Add issues for export."""+ for issue in issues:+ if hasattr(issue, "to_dict"):+ self.issues.append(issue.to_dict())+ elif isinstance(issue, dict):+ self.issues.append(issue)++ def export_csv(self, filepath: str | Path) -> None:+ """Export issues to CSV."""+ if not self.issues:+ return++ fieldnames = list(self.issues[0].keys())++ with open(filepath, "w", newline="") as f:+ writer = csv.DictWriter(f, fieldnames=fieldnames)+ writer.writeheader()+ writer.writerows(self.issues)++ def export_json(self, filepath: str | Path) -> None:+ """Export issues to JSON."""+ with open(filepath, "w") as f:+ json.dump(self.issues, f, indent=2, default=str)++ def export_markdown(self, filepath: str | Path) -> None:+ """Export issues to Markdown."""+ md = "# Model Check Issues\\n\\n"+ md += f"**Total Issues:** {len(self.issues)}\\n\\n"+ md += "| Element ID | Type | Issue | Severity |\\n"+ md += "|------------|------|-------|----------|\\n"++ for issue in self.issues:+ md += f"| {issue.get('element_id', 'N/A')} | {issue.get('element_type', 'N/A')} | {issue.get('issue_type', 'N/A')} | {issue.get('severity', 'N/A')} |\\n"++ with open(filepath, "w") as f:+ f.write(md)+++# SCAFFOLD 9: MCP Integration and CLI++class ModelCheckerCLI:+ """Command-line interface for model checker (Task 9.2)."""++ def __init__(self) -> None:+ """Initialize CLI."""+ self.results: dict[str, Any] = {}++ def run_checks(+ self, project: str, checks: list[str] | None = None+ ) -> dict[str, Any]:+ """Run model checks from CLI.++ Args:+ project: Project file path+ checks: List of check types to run (None = all)++ Returns:+ Dictionary of check results+ """+ self.results = {+ "project": project,+ "timestamp": datetime.now().isoformat(),+ "checks_run": checks or ["all"],+ "total_issues": 0,+ "issues_by_category": {},+ }++ return self.results++ def format_output(self, format: str = "text") -> str:+ """Format results for display.++ Args:+ format: Output format (text, json)++ Returns:+ Formatted results string+ """+ if format == "json":+ return json.dumps(self.results, indent=2)++ # Text format+ output = f"Model Check Results for {self.results['project']}\\n"+ output += f"Timestamp: {self.results['timestamp']}\\n"+ output += f"Checks Run: {', '.join(self.results['checks_run'])}\\n"+ output += f"Total Issues: {self.results['total_issues']}\\n"++ return output+++class AutomatedCheckRunner:+ """Automated check runner with scheduling (Task 9.3)."""++ def __init__(self) -> None:+ """Initialize automated check runner."""+ self.scheduled_checks: list[dict[str, Any]] = []+ self.last_run: datetime | None = None++ def schedule_check(+ self,+ check_type: str,+ interval_hours: float = 24.0,+ on_events: list[str] | None = None,+ ) -> None:+ """Schedule a check to run automatically.++ Args:+ check_type: Type of check to run+ interval_hours: Run interval in hours+ on_events: Events that trigger check (e.g., ["save", "sync"])+ """+ self.scheduled_checks.append(+ {+ "check_type": check_type,+ "interval_hours": interval_hours,+ "on_events": on_events or [],+ "last_run": None,+ }+ )++ def should_run_check(self, check: dict[str, Any]) -> bool:+ """Check if a scheduled check should run now."""+ if check["last_run"] is None:+ return True++ # Check time interval+ from datetime import timedelta++ now = datetime.now()+ elapsed = now - check["last_run"]+ interval = timedelta(hours=check["interval_hours"])++ return elapsed >= interval++ def run_scheduled_checks(self) -> list[dict[str, Any]]:+ """Run all scheduled checks that are due.++ Returns:+ List of check results+ """+ results = []++ for check in self.scheduled_checks:+ if self.should_run_check(check):+ result = {"check_type": check["check_type"], "ran": True, "timestamp": datetime.now().isoformat()}+ results.append(result)+ check["last_run"] = datetime.now()++ self.last_run = datetime.now()+ return results++ def trigger_check_on_event(self, event: str) -> list[dict[str, Any]]:+ """Trigger checks configured for a specific event.++ Args:+ event: Event name (e.g., "save", "sync")++ Returns:+ List of triggered check results+ """+ results = []++ for check in self.scheduled_checks:+ if event in check["on_events"]:+ result = {+ "check_type": check["check_type"],+ "triggered_by": event,+ "timestamp": datetime.now().isoformat(),+ }+ results.append(result)+ check["last_run"] = datetime.now()++ return resultsdiff --git a/packages/model-checker/tests/test_reporting_and_cli.py b/packages/model-checker/tests/test_reporting_and_cli.pynew file mode 100644index 0000000..434ad61--- /dev/null+++ b/packages/model-checker/tests/test_reporting_and_cli.py@@ -0,0 +1,247 @@+"""Test reporting and CLI features (Scaffolds 8 & 9)."""++import tempfile+from pathlib import Path++from model_checker.reporting import (+ AutomatedCheckRunner,+ HTMLReportGenerator,+ IssuePrioritizer,+ ModelCheckerCLI,+ ReportExporter,+)+++# SCAFFOLD 8 TESTS: Reporting++def test_html_report_generator():+ """Test HTML report generation."""+ generator = HTMLReportGenerator("Test Project")++ issues = [+ {+ "element_id": "wall_1",+ "element_type": "wall",+ "issue_type": "undersized",+ "description": "Wall too thin",+ "severity": "critical",+ }+ ]++ generator.add_issues(issues)+ html = generator.generate_html()++ assert "Test Project" in html+ assert "wall_1" in html+ assert "critical" in html+++def test_html_report_save():+ """Test saving HTML report to file."""+ generator = HTMLReportGenerator("Save Test")+ generator.add_issues([{"element_id": "test", "severity": "low"}])++ with tempfile.TemporaryDirectory() as tmpdir:+ filepath = Path(tmpdir) / "report.html"+ generator.save_html(filepath)++ assert filepath.exists()+ content = filepath.read_text()+ assert "Save Test" in content+++def test_issue_prioritizer():+ """Test issue prioritization."""+ prioritizer = IssuePrioritizer()++ issues = [+ {"severity": "low", "description": "Low issue"},+ {"severity": "critical", "description": "Critical issue"},+ {"severity": "medium", "description": "Medium issue"},+ {"severity": "high", "description": "High issue"},+ ]++ prioritizer.add_issues(issues)+ prioritized = prioritizer.prioritize()++ assert prioritized[0]["severity"] == "critical"+ assert prioritized[-1]["severity"] == "low"+++def test_issue_prioritizer_top_issues():+ """Test getting top priority issues."""+ prioritizer = IssuePrioritizer()++ issues = [{"severity": f"issue_{i}"} for i in range(20)]+ prioritizer.add_issues(issues)++ top10 = prioritizer.get_top_issues(limit=10)+ assert len(top10) == 10+++def test_report_exporter_csv():+ """Test exporting to CSV."""+ exporter = ReportExporter()++ issues = [+ {"element_id": "1", "type": "wall", "severity": "high"},+ {"element_id": "2", "type": "beam", "severity": "medium"},+ ]++ exporter.add_issues(issues)++ with tempfile.TemporaryDirectory() as tmpdir:+ filepath = Path(tmpdir) / "issues.csv"+ exporter.export_csv(filepath)++ assert filepath.exists()+ content = filepath.read_text()+ assert "element_id" in content+ assert "wall" in content+++def test_report_exporter_json():+ """Test exporting to JSON."""+ exporter = ReportExporter()++ issues = [{"element_id": "wall_1", "severity": "critical"}]+ exporter.add_issues(issues)++ with tempfile.TemporaryDirectory() as tmpdir:+ filepath = Path(tmpdir) / "issues.json"+ exporter.export_json(filepath)++ assert filepath.exists()+ import json++ with open(filepath) as f:+ data = json.load(f)+ assert len(data) == 1+++def test_report_exporter_markdown():+ """Test exporting to Markdown."""+ exporter = ReportExporter()++ issues = [{"element_id": "beam_1", "element_type": "beam", "severity": "high"}]+ exporter.add_issues(issues)++ with tempfile.TemporaryDirectory() as tmpdir:+ filepath = Path(tmpdir) / "issues.md"+ exporter.export_markdown(filepath)++ assert filepath.exists()+ content = filepath.read_text()+ assert "beam_1" in content+ assert "| " in content # Markdown table+++# SCAFFOLD 9 TESTS: CLI and Automation++def test_cli_run_checks():+ """Test CLI check running."""+ cli = ModelCheckerCLI()++ results = cli.run_checks("test_project.rvt", checks=["clash", "naming"])++ assert results["project"] == "test_project.rvt"+ assert "clash" in results["checks_run"]+ assert "timestamp" in results+++def test_cli_format_text():+ """Test CLI text formatting."""+ cli = ModelCheckerCLI()+ cli.run_checks("test.rvt")++ output = cli.format_output(format="text")++ assert "test.rvt" in output+ assert "Total Issues" in output+++def test_cli_format_json():+ """Test CLI JSON formatting."""+ cli = ModelCheckerCLI()+ cli.run_checks("test.rvt")++ output = cli.format_output(format="json")++ import json++ data = json.loads(output)+ assert data["project"] == "test.rvt"+++def test_automated_check_runner():+ """Test automated check scheduling."""+ runner = AutomatedCheckRunner()++ runner.schedule_check("clash_detection", interval_hours=24.0)+ runner.schedule_check("naming_validation", on_events=["save"])++ assert len(runner.scheduled_checks) == 2+++def test_scheduled_check_running():+ """Test running scheduled checks."""+ runner = AutomatedCheckRunner()++ runner.schedule_check("test_check", interval_hours=0.001) # Very short interval++ results = runner.run_scheduled_checks()++ assert len(results) == 1+ assert results[0]["check_type"] == "test_check"+++def test_event_triggered_checks():+ """Test event-triggered checks."""+ runner = AutomatedCheckRunner()++ runner.schedule_check("on_save_check", on_events=["save"])+ runner.schedule_check("on_sync_check", on_events=["sync"])++ results = runner.trigger_check_on_event("save")++ assert len(results) == 1+ assert results[0]["triggered_by"] == "save"+++def test_complete_reporting_workflow():+ """Test complete reporting workflow."""+ # Generate issues+ issues = [+ {"element_id": "wall_1", "severity": "critical", "description": "Critical wall issue"},+ {"element_id": "beam_1", "severity": "high", "description": "High beam issue"},+ {"element_id": "door_1", "severity": "medium", "description": "Medium door issue"},+ ]++ # Prioritize+ prioritizer = IssuePrioritizer()+ prioritizer.add_issues(issues)+ top_issues = prioritizer.get_top_issues(limit=2)++ assert len(top_issues) == 2+ assert top_issues[0]["severity"] == "critical"++ # Generate HTML report+ html_gen = HTMLReportGenerator("Complete Workflow Test")+ html_gen.add_issues(issues)+ html = html_gen.generate_html()++ assert "wall_1" in html+ assert "Critical wall issue" in html++ # Export to multiple formats+ exporter = ReportExporter()+ exporter.add_issues(issues)++ with tempfile.TemporaryDirectory() as tmpdir:+ exporter.export_csv(Path(tmpdir) / "issues.csv")+ exporter.export_json(Path(tmpdir) / "issues.json")+ exporter.export_markdown(Path(tmpdir) / "issues.md")++ assert (Path(tmpdir) / "issues.csv").exists()+ assert (Path(tmpdir) / "issues.json").exists()+ assert (Path(tmpdir) / "issues.md").exists()