Initial commit: mcp-civil-compliance

README.md

@@ -0,0 +1,85 @@
+---
+title: MCP Civil Compliance Checker
+emoji: 🏗️
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.24.0
+app_file: app.py
+pinned: false
+tags:
+  - building-mcp-track-enterprise
+  - mcp
+  - model-context-protocol
+  - hackathon
+---
+
+# MCP Civil Compliance Checker
+
+Building code compliance MCP server with IFC parsing and validation
+
+## 🎯 MCP 1st Birthday Hackathon Submission
+
+**Track:** Building Mcp Track Enterprise
+
+## 📖 About
+
+This project is an MCP (Model Context Protocol) server that provides tools for building code compliance mcp server with ifc parsing and validation.
+
+## 🚀 Features
+
+### MCP Server Tools
+
+[Tool descriptions will be added here]
+
+## 🛠️ Technical Stack
+
+- **Framework:** FastAPI + MCP Protocol
+- **UI:** Gradio 5.24.0
+- **Language:** Python 3.10+
+
+## 📦 Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## 🎮 Usage
+
+### As a Gradio App (This Space)
+
+Simply use the interface above to interact with the MCP tools through a user-friendly UI.
+
+### As an MCP Server
+
+```bash
+python server/app.py
+```
+
+The MCP server will start on the configured port and expose the following endpoints:
+- `GET /tools` - List all available MCP tools
+- `POST /invoke` - Invoke a specific tool
+- `GET /health` - Health check
+
+## 📝 MCP Integration
+
+This server can be integrated with MCP-compatible clients like:
+- Claude Desktop
+- Cursor
+- Other MCP-enabled applications
+
+## 🎥 Demo Video
+
+[Demo video link will be added here]
+
+## 👥 Team
+
+[Team member information]
+
+## 📄 License
+
+[License information]
+
+## 🙏 Acknowledgments
+
+Built for the MCP 1st Birthday Hackathon (November 14-30, 2025)

app.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""
+HuggingFace Space entry point for mcp-civil-compliance
+"""
+import sys
+import os
+
+# Add current directory to path
+sys.path.insert(0, os.path.dirname(__file__))
+
+# Import and launch the Gradio app
+from gradio_app import demo
+
+if __name__ == "__main__":
+    demo.launch()

gradio_app.py

@@ -0,0 +1,80 @@
+import gradio as gr
+import sys
+import os
+import json
+
+# Add current directory to path
+sys.path.insert(0, os.path.dirname(__file__))
+
+from shared_ui import components
+from shared_assets import storage
+from server.parser import ifc_parser
+from server.rules_engine import engine
+from shared_report import report
+
+PROJECT_NAME = "civil_compliance"
+
+DEFAULT_RULES = """
+max_height: 20.0
+min_area: 50.0
+"""
+
+def process_pipeline(file_obj, rules_text):
+    if file_obj is None:
+        return "Please upload a file.", None, None
+
+    # 1. Save Asset
+    saved_path = storage.save_file(PROJECT_NAME, file_obj.name)
+    
+    # 2. Parse
+    try:
+        metrics = ifc_parser.parse_model(saved_path)
+    except Exception as e:
+        return f"Parsing Error: {e}", None, None
+        
+    # 3. Validate
+    try:
+        rules = engine.load_rules(rules_text)
+        validation = engine.evaluate(metrics, rules)
+    except Exception as e:
+        return f"Validation Error: {e}", None, None
+
+    # 4. Generate Report
+    report_data = {
+        "project_name": metrics.get("project_name", "Unknown"),
+        "date": "2023-10-27", # Dynamic date in real app
+        "summary": "Passed" if validation["passed"] else "Failed",
+        "validation_details": json.dumps(validation["checks"], indent=2)
+    }
+    
+    report_path = saved_path + "_report.html"
+    report.create_report("compliance", report_data, report_path)
+
+    # Format output for UI
+    result_summary = f"**Status:** {'✅ Passed' if validation['passed'] else '❌ Failed'}\n\n"
+    result_summary += f"**Metrics:**\n{json.dumps(metrics, indent=2)}"
+    
+    return result_summary, validation["checks"], report_path
+
+with gr.Blocks(css=components.get_shared_css_path(), theme=gr.themes.Base()) as demo:
+    components.create_header("Civil Compliance Checker", "Validate IFC models against building codes.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_input = components.create_file_uploader(label="Upload IFC Model", file_types=[".ifc"])
+            rules_input = gr.Code(value=DEFAULT_RULES, language="yaml", label="Validation Rules (YAML)")
+            validate_btn = gr.Button("Validate Design", variant="primary", elem_classes=["primary"])
+        
+        with gr.Column(scale=2):
+            summary_output = gr.Markdown(label="Summary")
+            details_table = components.create_result_table(headers=["rule", "limit", "actual", "passed", "message"])
+            report_file = gr.File(label="Download Report")
+
+    validate_btn.click(
+        process_pipeline,
+        inputs=[file_input, rules_input],
+        outputs=[summary_output, details_table, report_file]
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_port=7860)

requirements.txt

@@ -0,0 +1 @@
+fastapi\nuvicorn\npydantic\ngradio>=5.0.0\nmarkdown2\nifcopenshell\npyyaml\nllama-index\nmodal\nqdrant-client\n

server/app.py

@@ -0,0 +1,93 @@
+import sys
+import os
+import logging
+
+# Ensure we can import shared modules and project modules
+project_root = os.path.join(os.path.dirname(__file__), "../../../")
+sys.path.insert(0, project_root)
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from shared_mcp.app import app
+from shared_mcp.registry import registry
+from shared_mcp.models import ToolSchema
+from server.parser import ifc_parser
+from server.rules_engine import engine
+from server.rag.standards_index import rag_engine
+from server import modal_parser
+
+logger = logging.getLogger(__name__)
+
+# Register Tools
+
+# 1. Parse IFC
+registry.register(
+    ToolSchema(
+        name="parse_ifc",
+        description="Parses an IFC file to extract metrics.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string", "description": "Absolute path to the IFC file"}
+            },
+            "required": ["file_path"]
+        }
+    ),
+    ifc_parser.parse_model
+)
+
+# 2. Evaluate Rules
+def evaluate_rules_wrapper(metrics: dict, rules_yaml: str):
+    rules = engine.load_rules(rules_yaml)
+    return engine.evaluate(metrics, rules)
+
+registry.register(
+    ToolSchema(
+        name="evaluate_rules",
+        description="Evaluates building metrics against a set of rules.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "object", "description": "Metrics dictionary"},
+                "rules_yaml": {"type": "string", "description": "Rules in YAML format"}
+            },
+            "required": ["metrics", "rules_yaml"]
+        }
+    ),
+    evaluate_rules_wrapper
+)
+
+# 3. Query Standards (RAG)
+registry.register(
+    ToolSchema(
+        name="query_standards",
+        description="Queries building standards using RAG.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Question about standards"}
+            },
+            "required": ["query"]
+        }
+    ),
+    rag_engine.query
+)
+
+# 4. Parse IFC (Cloud/Modal)
+registry.register(
+    ToolSchema(
+        name="parse_ifc_cloud",
+        description="Parses an IFC file using Modal cloud compute.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string", "description": "Absolute path to the IFC file"}
+            },
+            "required": ["file_path"]
+        }
+    ),
+    modal_parser.parse_model_remote
+)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8003)

server/modal_parser.py

@@ -0,0 +1,96 @@
+import modal
+import logging
+import os
+import sys
+
+# Define the image with dependencies
+image = modal.Image.debian_slim().pip_install("ifcopenshell")
+
+app = modal.App("mcp-civil-parser")
+
+@app.function(image=image)
+def parse_ifc_cloud(file_content: bytes, filename: str):
+    """
+    Parses an IFC file in the cloud using Modal.
+    """
+    import ifcopenshell
+    import ifcopenshell.util.element
+    import os
+    
+    # Save to temp file
+    temp_path = f"/tmp/{filename}"
+    with open(temp_path, "wb") as f:
+        f.write(file_content)
+        
+    try:
+        model = ifcopenshell.open(temp_path)
+    except Exception as e:
+        return {"error": str(e)}
+
+    metrics = {
+        "filename": filename,
+        "project_name": "Unknown",
+        "total_floor_area": 0.0,
+        "building_height": 0.0,
+        "num_storeys": 0,
+        "source": "Modal Cloud"
+    }
+
+    # Extract Project Name
+    project = model.by_type("IfcProject")
+    if project:
+        metrics["project_name"] = project[0].Name
+
+    # Extract Storeys and Height
+    storeys = model.by_type("IfcBuildingStorey")
+    metrics["num_storeys"] = len(storeys)
+    
+    min_elev = float('inf')
+    max_elev = float('-inf')
+    
+    for storey in storeys:
+        elevation = storey.Elevation
+        if elevation is not None:
+            min_elev = min(min_elev, elevation)
+            max_elev = max(max_elev, elevation)
+            
+    if min_elev != float('inf') and max_elev != float('-inf'):
+        metrics["building_height"] = max_elev - min_elev
+
+    # Extract Floor Area
+    total_area = 0.0
+    spaces = model.by_type("IfcSpace")
+    for space in spaces:
+        psets = ifcopenshell.util.element.get_psets(space)
+        for pset_name, pset_data in psets.items():
+            if "Area" in pset_data:
+                total_area += float(pset_data["Area"])
+            elif "GrossFloorArea" in pset_data:
+                 total_area += float(pset_data["GrossFloorArea"])
+            elif "NetFloorArea" in pset_data:
+                 total_area += float(pset_data["NetFloorArea"])
+                 
+    metrics["total_floor_area"] = total_area
+    
+    return metrics
+
+def parse_model_remote(file_path: str):
+    """
+    Wrapper to call the Modal function.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+        
+    with open(file_path, "rb") as f:
+        content = f.read()
+    
+    filename = os.path.basename(file_path)
+    
+    # In a real app, we would use `with app.run():` or `f.remote()`
+    # For the hackathon demo, we'll try to invoke it if configured.
+    try:
+        with app.run():
+            return parse_ifc_cloud.remote(content, filename)
+    except Exception as e:
+        # Fallback or error
+        raise ValueError(f"Modal execution failed (Did you run 'modal token set'?): {e}")

server/parser/ifc_parser.py

@@ -0,0 +1,71 @@
+import ifcopenshell
+import ifcopenshell.util.element
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+def parse_model(file_path: str) -> Dict[str, Any]:
+    """
+    Parses an IFC file to extract basic building metrics.
+    
+    Args:
+        file_path: Absolute path to the IFC file.
+        
+    Returns:
+        Dictionary containing extracted metrics (floor_area, height, etc.).
+    """
+    try:
+        model = ifcopenshell.open(file_path)
+    except Exception as e:
+        logger.error(f"Failed to open IFC file {file_path}: {e}")
+        raise ValueError(f"Could not open IFC file: {e}")
+
+    metrics = {
+        "filename": file_path.split("/")[-1],
+        "project_name": "Unknown",
+        "total_floor_area": 0.0,
+        "building_height": 0.0,
+        "num_storeys": 0,
+        "units": "meters" # Default assumption, should parse from project
+    }
+
+    # Extract Project Name
+    project = model.by_type("IfcProject")
+    if project:
+        metrics["project_name"] = project[0].Name
+
+    # Extract Storeys and Height
+    storeys = model.by_type("IfcBuildingStorey")
+    metrics["num_storeys"] = len(storeys)
+    
+    min_elev = float('inf')
+    max_elev = float('-inf')
+    
+    for storey in storeys:
+        elevation = storey.Elevation
+        if elevation is not None:
+            min_elev = min(min_elev, elevation)
+            max_elev = max(max_elev, elevation)
+            
+    if min_elev != float('inf') and max_elev != float('-inf'):
+        metrics["building_height"] = max_elev - min_elev
+
+    # Extract Floor Area (Simplified estimation based on slabs or spaces)
+    # This is a heuristic; real implementation would need precise geometry
+    total_area = 0.0
+    spaces = model.by_type("IfcSpace")
+    for space in spaces:
+        # Try to get area from property sets
+        psets = ifcopenshell.util.element.get_psets(space)
+        for pset_name, pset_data in psets.items():
+            if "Area" in pset_data:
+                total_area += float(pset_data["Area"])
+            elif "GrossFloorArea" in pset_data:
+                 total_area += float(pset_data["GrossFloorArea"])
+            elif "NetFloorArea" in pset_data:
+                 total_area += float(pset_data["NetFloorArea"])
+                 
+    metrics["total_floor_area"] = total_area
+
+    return metrics

server/rag/standards_index.py

@@ -0,0 +1,54 @@
+import logging
+import os
+from typing import List
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Document
+from llama_index.core.node_parser import SentenceSplitter
+
+logger = logging.getLogger(__name__)
+
+class StandardsIndex:
+    def __init__(self, data_dir: str):
+        self.data_dir = data_dir
+        self.index = None
+        self._initialize_index()
+
+    def _initialize_index(self):
+        """Initializes the VectorStoreIndex from documents in data_dir."""
+        if not os.path.exists(self.data_dir):
+            os.makedirs(self.data_dir, exist_ok=True)
+            # Create a dummy standard if empty
+            with open(os.path.join(self.data_dir, "sample_code.txt"), "w") as f:
+                f.write("Standard 101: Max building height is 20 meters. Min floor area is 50 sqm.")
+        
+        # Check for OpenAI Key
+        if not os.environ.get("OPENAI_API_KEY"):
+            logger.warning("OPENAI_API_KEY not found. RAG will be disabled/mocked.")
+            return
+
+        try:
+            documents = SimpleDirectoryReader(self.data_dir).load_data()
+            self.index = VectorStoreIndex.from_documents(
+                documents,
+                transformations=[SentenceSplitter(chunk_size=512)]
+            )
+            logger.info(f"Initialized LlamaIndex with {len(documents)} documents.")
+        except Exception as e:
+            logger.error(f"Failed to initialize LlamaIndex: {e}")
+
+    def query(self, question: str) -> str:
+        """Queries the index."""
+        if not self.index:
+            return "RAG System not initialized (Missing OpenAI Key or Index Error). Standard 101 says Max Height 20m."
+        
+        try:
+            query_engine = self.index.as_query_engine()
+            response = query_engine.query(question)
+            return str(response)
+        except Exception as e:
+            logger.error(f"Query failed: {e}")
+            return f"Error querying standards: {e}"
+
+# Singleton
+# Assumes 'standards' folder is in the project root
+STANDARDS_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "standards")
+rag_engine = StandardsIndex(STANDARDS_DIR)

server/rules_engine.py

@@ -0,0 +1,68 @@
+import yaml
+import logging
+from typing import Dict, Any, List
+
+logger = logging.getLogger(__name__)
+
+class RuleEngine:
+    def __init__(self):
+        pass
+
+    def load_rules(self, rules_yaml: str) -> Dict[str, Any]:
+        """Loads rules from a YAML string."""
+        try:
+            return yaml.safe_load(rules_yaml)
+        except yaml.YAMLError as e:
+            logger.error(f"Error parsing rules YAML: {e}")
+            raise ValueError(f"Invalid rules format: {e}")
+
+    def evaluate(self, metrics: Dict[str, Any], rules: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Evaluates metrics against a set of rules.
+        
+        Args:
+            metrics: Dictionary of extracted metrics (e.g., {'building_height': 15.0}).
+            rules: Dictionary of rules (e.g., {'max_height': 12.0}).
+            
+        Returns:
+            Dictionary with pass/fail results and details.
+        """
+        results = {
+            "passed": True,
+            "checks": []
+        }
+        
+        # Check Max Height
+        if "max_height" in rules:
+            limit = rules["max_height"]
+            actual = metrics.get("building_height", 0)
+            passed = actual <= limit
+            results["checks"].append({
+                "rule": "Max Height",
+                "limit": limit,
+                "actual": actual,
+                "passed": passed,
+                "message": "Height within limits" if passed else f"Height {actual} exceeds limit {limit}"
+            })
+            if not passed:
+                results["passed"] = False
+
+        # Check Min Area
+        if "min_area" in rules:
+            limit = rules["min_area"]
+            actual = metrics.get("total_floor_area", 0)
+            passed = actual >= limit
+            results["checks"].append({
+                "rule": "Min Floor Area",
+                "limit": limit,
+                "actual": actual,
+                "passed": passed,
+                "message": "Area meets minimum" if passed else f"Area {actual} is below minimum {limit}"
+            })
+            if not passed:
+                results["passed"] = False
+                
+        return results
+
+# Singleton for simple usage
+engine = RuleEngine()

server/tools.py

@@ -0,0 +1,268 @@
+"""Compliance helpers for CAD/IFC-driven MCP server."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+import json
+import yaml
+
+
+@dataclass
+class ToolResult:
+    title: str
+    summary: str
+    artifacts: Dict[str, str]
+
+
+class IfcMetricsTool:
+    """Parse simplified IFC-like JSON to extract metrics used by rules."""
+
+    def extract_metrics(self, path: str) -> ToolResult:
+        data = json.loads(Path(path).read_text())
+        metrics = {
+            "height_m": float(data.get("height_m", 0)),
+            "footprint_area_m2": float(data.get("footprint_area_m2", 0)),
+            "num_floors": int(data.get("num_floors", 0)),
+        }
+        summary = f"Height: {metrics['height_m']} m, area: {metrics['footprint_area_m2']} m^2, floors: {metrics['num_floors']}"
+        return ToolResult(title="IFC metrics", summary=summary, artifacts={"metrics": json.dumps(metrics, indent=2)})
+
+
+class RuleEvaluator:
+    def evaluate(self, metrics: Dict[str, float], rules_path: str) -> ToolResult:
+        rule_pack = yaml.safe_load(Path(rules_path).read_text())
+        results: List[Dict[str, object]] = []
+        passed = True
+        for rule in rule_pack.get("rules", []):
+            field = rule["field"]
+            op = rule.get("op", "<=")
+            threshold = rule.get("value", 0)
+            observed = metrics.get(field, 0)
+            if op == "<=":
+                ok = observed <= threshold
+            elif op == ">=":
+                ok = observed >= threshold
+            else:
+                ok = False
+            results.append({"rule": rule.get("name", field), "pass": ok, "observed": observed, "threshold": threshold})
+            passed = passed and ok
+
+        summary = "All rules passed" if passed else "Rule violations detected"
+        return ToolResult(
+            title="Compliance evaluation",
+            summary=summary,
+            artifacts={"results": json.dumps(results, indent=2), "passed": json.dumps(passed)},
+        )
+
+
+class GeminiDocTool:
+    def draft_prompt(self, description: str, missing_items: List[str]) -> ToolResult:
+        checklist = "\n".join([f"- {item}" for item in missing_items])
+        prompt = (
+            "You are a permitting reviewer. Summarize the project description and list missing artifacts.\n"
+            f"Description: {description}\nMissing items:\n{checklist}"
+        )
+        return ToolResult(
+            title="Gemini document prompt",
+            summary="Prompt prepared for Gemini-powered review.",
+            artifacts={"prompt": prompt},
+        )
+
+
+class StandardCatalogTool:
+    """Search ISO/IEC/EN standard snippets for quick lookups."""
+
+    def __init__(self, catalog_path: Optional[str] = None) -> None:
+        base = Path(__file__).resolve().parent.parent
+        self.catalog_path = Path(catalog_path or base / "standards" / "catalog.yaml")
+
+    def search(self, keyword: str, jurisdiction: Optional[str] = None, tag: Optional[str] = None) -> ToolResult:
+        catalog = yaml.safe_load(self.catalog_path.read_text()) or {}
+        entries: List[Dict[str, str]] = catalog.get("standards", [])
+        keyword_lower = keyword.lower()
+        filtered = []
+        for entry in entries:
+            title = entry.get("title", "")
+            desc = entry.get("summary", "")
+            jurisdiction_match = True if not jurisdiction else jurisdiction.lower() in entry.get("jurisdiction", "").lower()
+            tag_match = True if not tag else tag.lower() in " ".join(entry.get("tags", [])).lower()
+            keyword_match = keyword_lower in title.lower() or keyword_lower in desc.lower() or keyword_lower in entry.get("id", "").lower()
+            if jurisdiction_match and tag_match and keyword_match:
+                filtered.append(entry)
+
+        summary = f"Found {len(filtered)} standards matching '{keyword}'"
+        return ToolResult(title="Standards lookup", summary=summary, artifacts={"standards": json.dumps(filtered, indent=2)})
+
+
+class BuildingCodeChecklistTool:
+    """Generate building-code and ISO alignment checklist for a project brief."""
+
+    def generate(self, occupancy: str, construction_type: str, height_m: float) -> ToolResult:
+        checklist = [
+            {
+                "item": "IBC/IRC occupancy confirmation",
+                "details": f"Verify occupancy group '{occupancy}' against Chapter 3 use definitions.",
+            },
+            {
+                "item": "Construction type vs height",
+                "details": (
+                    f"Check {construction_type} height {height_m} m against IBC Table 504 allowances; flag podium separations if needed."
+                ),
+            },
+            {
+                "item": "Fire resistance & egress",
+                "details": "Confirm fire ratings, stair/exit widths, and travel distance per IBC Chapters 7, 10; align with NFPA 101 where applicable.",
+            },
+            {
+                "item": "Accessibility",
+                "details": "Coordinate ANSI A117.1 and ISO 21542 clearances for doors, ramps, and toilets; ensure jurisdictional amendments are captured.",
+            },
+            {
+                "item": "Energy + sustainability",
+                "details": "Map envelope/MEP targets to IECC/ASHRAE 90.1 plus ISO 52000 energy performance indicators.",
+            },
+            {
+                "item": "Digital delivery",
+                "details": "Ensure BIM deliverables follow ISO 19650 naming and exchange information requirements (EIR/BEP).",
+            },
+        ]
+        return ToolResult(
+            title="Building code checklist",
+            summary="Checklist drafted with IBC/ISO references.",
+            artifacts={"checklist": json.dumps(checklist, indent=2)},
+        )
+
+
+class IsoMappingTool:
+    """Map project artifacts to relevant ISO/EN references for documentation."""
+
+    def __init__(self, mapping_path: Optional[str] = None) -> None:
+        base = Path(__file__).resolve().parent.parent
+        self.mapping_path = Path(mapping_path or base / "standards" / "iso_mapping.yaml")
+
+    def map_artifacts(self, artifact_types: List[str]) -> ToolResult:
+        mapping_doc = yaml.safe_load(self.mapping_path.read_text()) or {}
+        mappings = mapping_doc.get("mappings", [])
+        matches: List[Dict[str, str]] = []
+        lower_artifacts = [a.lower() for a in artifact_types]
+        for entry in mappings:
+            if any(token in lower_artifacts for token in [entry.get("artifact", "").lower()] + [t.lower() for t in entry.get("aliases", [])]):
+                matches.append(entry)
+
+        summary = f"Matched {len(matches)} artifact types to ISO/EN references"
+        return ToolResult(
+            title="ISO/EN mappings",
+            summary=summary,
+            artifacts={"mappings": json.dumps(matches, indent=2)},
+        )
+
+
+class HealthcareSpaceProgramTool:
+    """Check healthcare department spaces against minimum areas."""
+
+    def __init__(self, space_path: Optional[str] = None) -> None:
+        base = Path(__file__).resolve().parent.parent
+        self.space_path = Path(space_path or base / "standards" / "healthcare_spaces.yaml")
+
+    def evaluate(self, program: List[Dict[str, object]]) -> ToolResult:
+        config = yaml.safe_load(self.space_path.read_text()) or {}
+        standards = {entry.get("space", "").lower(): entry for entry in config.get("spaces", [])}
+        results: List[Dict[str, object]] = []
+        for item in program:
+            name = str(item.get("space", "")).lower()
+            provided = float(item.get("area_m2", 0))
+            std = standards.get(name)
+            if std:
+                min_area = float(std.get("min_area_m2", 0))
+                ok = provided >= min_area
+                results.append(
+                    {
+                        "space": item.get("space", ""),
+                        "provided_m2": provided,
+                        "min_m2": min_area,
+                        "pass": ok,
+                        "notes": std.get("notes", ""),
+                    }
+                )
+            else:
+                results.append(
+                    {
+                        "space": item.get("space", ""),
+                        "provided_m2": provided,
+                        "min_m2": None,
+                        "pass": None,
+                        "notes": "No healthcare baseline found",
+                    }
+                )
+
+        summary = "Healthcare program validated" if all(r.get("pass", True) is not False for r in results) else "Program needs attention"
+        return ToolResult(
+            title="Healthcare space check",
+            summary=summary,
+            artifacts={"results": json.dumps(results, indent=2)},
+        )
+
+
+class HealthcareCodeBundleTool:
+    """Return key US healthcare code touchpoints for a facility type."""
+
+    def summarize(self, facility_type: str, risk_category: Optional[str] = None) -> ToolResult:
+        ft_lower = facility_type.lower()
+        bundle: List[Dict[str, str]] = [
+            {
+                "code": "IBC 2021 - Group I-2",
+                "focus": "Occupancy definition, smoke compartment sizing, egress width for patient care areas.",
+            },
+            {
+                "code": "NFPA 101 Life Safety Code",
+                "focus": "Horizontal/vertical separation, defend-in-place strategies, healthcare corridor requirements.",
+            },
+            {
+                "code": "NFPA 99 Health Care Facilities Code",
+                "focus": "Medical gas categories, electrical systems, ITM for critical branches.",
+            },
+            {
+                "code": "FGI 2022 Guidelines",
+                "focus": "Space sizes, clearances, nurse station visibility, sterile/soiled flows.",
+            },
+        ]
+
+        if "outpatient" in ft_lower:
+            bundle.append(
+                {
+                    "code": "CMS ASC (41 CFR 416)",
+                    "focus": "Ambulatory surgical center infection control, anesthesia gas storage, recovery bays.",
+                }
+            )
+        else:
+            bundle.append(
+                {
+                    "code": "CMS Conditions of Participation (42 CFR 482)",
+                    "focus": "Emergency services, patient rights, physical environment maintenance for hospitals.",
+                }
+            )
+
+        if risk_category:
+            bundle.append(
+                {
+                    "code": "ASCE 7 Risk Category",
+                    "focus": f"Confirm essential facility structural/Seismic Design Category for risk category {risk_category}.",
+                }
+            )
+
+        summary = f"Healthcare code bundle for {facility_type}"
+        return ToolResult(title="Healthcare codes", summary=summary, artifacts={"bundle": json.dumps(bundle, indent=2)})
+
+
+__all__ = [
+    "ToolResult",
+    "IfcMetricsTool",
+    "RuleEvaluator",
+    "GeminiDocTool",
+    "StandardCatalogTool",
+    "BuildingCodeChecklistTool",
+    "IsoMappingTool",
+    "HealthcareSpaceProgramTool",
+    "HealthcareCodeBundleTool",
+]

shared_assets/__init__.py

@@ -0,0 +1 @@
+# Shared module

shared_assets/storage.py

@@ -0,0 +1,60 @@
+import os
+import shutil
+import uuid
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+ASSETS_ROOT = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "assets")
+
+def _get_project_dir(project_name: str) -> Path:
+    path = Path(ASSETS_ROOT) / project_name
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+def save_file(project_name: str, file_path: str, original_filename: Optional[str] = None) -> str:
+    """
+    Saves a file to the project's asset directory.
+    
+    Args:
+        project_name: Name of the project (e.g., 'civil', 'geo', 'video').
+        file_path: Path to the temporary file (e.g., from Gradio upload).
+        original_filename: Original name of the file.
+        
+    Returns:
+        Absolute path to the saved file.
+    """
+    project_dir = _get_project_dir(project_name)
+    
+    if original_filename:
+        filename = original_filename
+    else:
+        filename = f"{uuid.uuid4()}_{os.path.basename(file_path)}"
+        
+    # Sanitize filename (basic)
+    filename = "".join(c for c in filename if c.isalnum() or c in "._- ")
+    
+    dest_path = project_dir / filename
+    
+    try:
+        shutil.copy2(file_path, dest_path)
+        logger.info(f"Saved asset to {dest_path}")
+        return str(dest_path)
+    except Exception as e:
+        logger.error(f"Failed to save asset: {e}")
+        raise IOError(f"Failed to save asset: {e}")
+
+def list_files(project_name: str) -> List[str]:
+    """Lists all files in the project's asset directory."""
+    project_dir = _get_project_dir(project_name)
+    if not project_dir.exists():
+        return []
+    return [str(p) for p in project_dir.glob("*") if p.is_file()]
+
+def get_file_path(project_name: str, filename: str) -> Optional[str]:
+    """Gets the absolute path of a file if it exists."""
+    project_dir = _get_project_dir(project_name)
+    path = project_dir / filename
+    return str(path) if path.exists() else None

shared_mcp/__init__.py

@@ -0,0 +1 @@
+# Shared MCP Framework

shared_mcp/app.py

@@ -0,0 +1,47 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from .models import ToolRequest, ToolResponse, ToolSchema
+from .registry import registry
+from typing import List
+
+app = FastAPI(title="Shared MCP Server", version="0.1.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/tools", response_model=List[ToolSchema])
+async def list_tools():
+    """Lists all available tools."""
+    return registry.list_tools()
+
+@app.post("/invoke", response_model=ToolResponse)
+async def invoke_tool(request: ToolRequest):
+    """Invokes a specific tool."""
+    try:
+        result = await registry.invoke(request.tool_name, request.arguments)
+        
+        # Format result as MCP content list
+        content = []
+        if isinstance(result, str):
+            content.append({"type": "text", "text": result})
+        elif isinstance(result, dict) or isinstance(result, list):
+             import json
+             content.append({"type": "text", "text": json.dumps(result)})
+        else:
+             content.append({"type": "text", "text": str(result)})
+             
+        return ToolResponse(content=content)
+        
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}

shared_mcp/models.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, Field
+from typing import Dict, Any, Optional, List
+
+class ToolSchema(BaseModel):
+    name: str = Field(..., description="The name of the tool")
+    description: str = Field(..., description="A description of what the tool does")
+    input_schema: Dict[str, Any] = Field(..., description="JSON schema for the tool input")
+
+class ToolRequest(BaseModel):
+    tool_name: str
+    arguments: Dict[str, Any]
+
+class ToolResponse(BaseModel):
+    content: List[Dict[str, Any]]
+    is_error: bool = False

shared_mcp/registry.py

@@ -0,0 +1,45 @@
+from typing import Callable, Dict, List, Any
+from .models import ToolSchema
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ToolRegistry:
+    def __init__(self):
+        self._tools: Dict[str, ToolSchema] = {}
+        self._handlers: Dict[str, Callable] = {}
+
+    def register(self, schema: ToolSchema, handler: Callable):
+        """Registers a tool with its schema and handler function."""
+        if schema.name in self._tools:
+            logger.warning(f"Overwriting existing tool: {schema.name}")
+        
+        self._tools[schema.name] = schema
+        self._handlers[schema.name] = handler
+        logger.info(f"Registered tool: {schema.name}")
+
+    def get_tool(self, name: str) -> ToolSchema:
+        return self._tools.get(name)
+
+    def list_tools(self) -> List[ToolSchema]:
+        return list(self._tools.values())
+
+    async def invoke(self, name: str, arguments: Dict[str, Any]) -> Any:
+        handler = self._handlers.get(name)
+        if not handler:
+            raise ValueError(f"Tool not found: {name}")
+        
+        try:
+            # Support both async and sync handlers
+            if hasattr(handler, '__call__'):
+                import inspect
+                if inspect.iscoroutinefunction(handler):
+                    return await handler(**arguments)
+                else:
+                    return handler(**arguments)
+        except Exception as e:
+            logger.error(f"Error invoking tool {name}: {e}")
+            raise e
+
+# Global registry instance
+registry = ToolRegistry()

shared_report/__init__.py

@@ -0,0 +1 @@
+# Shared module

shared_report/report.py

@@ -0,0 +1,99 @@
+import logging
+from typing import Dict, Any
+import markdown2
+# import weasyprint # Commented out as it might require system deps like pango/cairo
+import os
+
+logger = logging.getLogger(__name__)
+
+# Placeholder for Gemini client
+# In a real implementation, we'd import the actual Gemini client wrapper
+class MockGeminiClient:
+    def generate_content(self, prompt: str) -> str:
+        return f"Generated report content based on: {prompt[:50]}..."
+
+gemini_client = MockGeminiClient()
+
+TEMPLATES = {
+    "compliance": """
+# Compliance Report
+**Project:** {project_name}
+**Date:** {date}
+
+## Summary
+{summary}
+
+## Validation Results
+{validation_details}
+""",
+    "geo": """
+# Geo Insights Report
+**Region:** {region_name}
+**Analysis Date:** {date}
+
+## Findings
+{findings}
+
+## Recommendations
+{recommendations}
+""",
+    "video": """
+# Video Production Summary
+**Project:** {project_name}
+
+## Pipeline Steps
+{pipeline_steps}
+
+## Script
+{script}
+"""
+}
+
+def generate_report_markdown(template_name: str, data: Dict[str, Any]) -> str:
+    """Generates a markdown report using a template and data."""
+    template = TEMPLATES.get(template_name)
+    if not template:
+        raise ValueError(f"Template not found: {template_name}")
+    
+    # Simple string formatting for now
+    # In production, use Jinja2
+    try:
+        return template.format(**data)
+    except KeyError as e:
+        logger.error(f"Missing data for template {template_name}: {e}")
+        return f"Error generating report: Missing data {e}"
+
+def generate_pdf(markdown_content: str, output_path: str):
+    """Converts markdown to PDF."""
+    html_content = markdown2.markdown(markdown_content)
+    
+    # Basic HTML wrapper with styles
+    full_html = f"""
+    <html>
+    <head>
+        <style>
+            body {{ font-family: sans-serif; padding: 20px; }}
+            h1 {{ color: #333; }}
+            h2 {{ color: #555; border-bottom: 1px solid #ccc; }}
+        </style>
+    </head>
+    <body>
+        {html_content}
+    </body>
+    </html>
+    """
+    
+    # For hackathon without weasyprint, we might just save HTML or Markdown
+    # If weasyprint was available:
+    # weasyprint.HTML(string=full_html).write_pdf(output_path)
+    
+    # Fallback: Save as HTML
+    with open(output_path.replace(".pdf", ".html"), "w") as f:
+        f.write(full_html)
+    logger.info(f"Report saved to {output_path.replace('.pdf', '.html')}")
+
+def create_report(template_name: str, data: Dict[str, Any], output_path: str):
+    """High-level function to create a report."""
+    md = generate_report_markdown(template_name, data)
+    generate_pdf(md, output_path)
+    return output_path

shared_ui/__init__.py

@@ -0,0 +1 @@
+# Shared module

shared_ui/components.py

@@ -0,0 +1,39 @@
+import gradio as gr
+import os
+
+def get_shared_css_path():
+    """Returns the absolute path to the shared CSS file."""
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    return os.path.join(current_dir, "style.css")
+
+def create_header(title: str, subtitle: str):
+    """Creates a standard header component."""
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(f"# {title}")
+            gr.Markdown(f"### {subtitle}")
+
+def create_file_uploader(label="Upload File", file_types=None):
+    """Creates a standardized file uploader."""
+    return gr.File(
+        label=label,
+        file_types=file_types or [],
+        type="filepath",
+        elem_classes=["upload-box"]
+    )
+
+def create_result_table(headers=None):
+    """Creates a standardized result table."""
+    return gr.Dataframe(
+        headers=headers,
+        interactive=False,
+        wrap=True
+    )
+
+def show_success_toast(message: str):
+    """(Placeholder) In a real app, this would trigger a client-side toast."""
+    return gr.Info(message)
+
+def show_error_toast(message: str):
+    """(Placeholder) In a real app, this would trigger a client-side toast."""
+    return gr.Warning(message)

shared_ui/style.css

@@ -0,0 +1,79 @@
+/* Shared Premium Dark Theme */
+:root {
+    --primary-color: #6366f1;
+    --secondary-color: #a855f7;
+    --background-dark: #0f172a;
+    --surface-dark: #1e293b;
+    --text-light: #f8fafc;
+    --text-dim: #94a3b8;
+}
+
+body {
+    background-color: var(--background-dark);
+    color: var(--text-light);
+    font-family: 'Inter', sans-serif;
+}
+
+.gradio-container {
+    background-color: var(--background-dark) !important;
+}
+
+/* Cards / Blocks */
+.block {
+    background-color: var(--surface-dark) !important;
+    border: 1px solid #334155 !important;
+    border-radius: 0.75rem !important;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+}
+
+/* Headers */
+h1, h2, h3 {
+    background: linear-gradient(to right, var(--primary-color), var(--secondary-color));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    font-weight: 700;
+}
+
+/* Buttons */
+button.primary {
+    background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
+    border: none !important;
+    color: white !important;
+    font-weight: 600 !important;
+    transition: transform 0.1s ease-in-out;
+}
+
+button.primary:hover {
+    transform: scale(1.02);
+    opacity: 0.9;
+}
+
+/* Tables */
+table {
+    border-collapse: collapse;
+    width: 100%;
+}
+
+th {
+    background-color: #334155;
+    color: var(--text-light);
+    padding: 0.75rem;
+    text-align: left;
+}
+
+td {
+    border-bottom: 1px solid #334155;
+    padding: 0.75rem;
+    color: var(--text-dim);
+}
+
+/* File Upload */
+.upload-box {
+    border: 2px dashed #475569 !important;
+    background-color: rgba(30, 41, 59, 0.5) !important;
+    transition: border-color 0.2s;
+}
+
+.upload-box:hover {
+    border-color: var(--primary-color) !important;
+}