ventilatepro-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventilatepro-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: VentilatePro CLI
 Project-URL: Homepage, https://ventilatepro.com/exam/cli/
 Project-URL: Documentation, https://ventilatepro.com/exam/cli/
@@ -47,6 +47,8 @@ ventilatepro projects show 1
 ventilatepro rooms list --project 1
 ventilatepro room-equipment summary --project 1
 ventilatepro room-equipment create --data '{"room": 501, "name": "Sterilizer", "heat_gain_value": 1.8, "heat_gain_unit": "KW"}'
+ventilatepro revit-imports review --project 1 --json
+ventilatepro revit-imports confirm 41 --project 1 --review-token <token-from-review> --yes
 ventilatepro categorization review --project 1 --output room-categorization.json
 ventilatepro categorization apply --project 1 --input room-categorization.json --yes
 ventilatepro ahus list --project 1
@@ -77,6 +79,11 @@ review resource or use the dedicated MCP tools. Review manifests default every
 room to rejected so ambiguous spaces remain visible until a category is
 explicitly accepted with a reason.
 
+For staged Revit imports, agents use `revit-imports review` or
+`vp_review_revit_import` first. The returned review token identifies the exact
+payload and diff that was inspected. Confirmation requires that unchanged token
+plus explicit `--yes` or MCP `confirm=true`; stale reviews are rejected.
+
 ## MCP setup
 
 1. In the VentilatePro web app, open Account Settings and create a CLI token with

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/README.md

@@ -32,6 +32,8 @@ ventilatepro projects show 1
 ventilatepro rooms list --project 1
 ventilatepro room-equipment summary --project 1
 ventilatepro room-equipment create --data '{"room": 501, "name": "Sterilizer", "heat_gain_value": 1.8, "heat_gain_unit": "KW"}'
+ventilatepro revit-imports review --project 1 --json
+ventilatepro revit-imports confirm 41 --project 1 --review-token <token-from-review> --yes
 ventilatepro categorization review --project 1 --output room-categorization.json
 ventilatepro categorization apply --project 1 --input room-categorization.json --yes
 ventilatepro ahus list --project 1
@@ -62,6 +64,11 @@ review resource or use the dedicated MCP tools. Review manifests default every
 room to rejected so ambiguous spaces remain visible until a category is
 explicitly accepted with a reason.
 
+For staged Revit imports, agents use `revit-imports review` or
+`vp_review_revit_import` first. The returned review token identifies the exact
+payload and diff that was inspected. Confirmation requires that unchanged token
+plus explicit `--yes` or MCP `confirm=true`; stale reviews are rejected.
+
 ## MCP setup
 
 1. In the VentilatePro web app, open Account Settings and create a CLI token with

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/tests/test_cli.py

@@ -7,10 +7,11 @@ from unittest import mock
 from typer.testing import CliRunner
 
 from ventilatepro import auth, config
-from ventilatepro.api_client import ApiError, NetworkError
+from ventilatepro.api_client import ApiClient, ApiError, NetworkError
 from ventilatepro.cli import app
 from ventilatepro.categorization import _classification_group_key
 from ventilatepro.queue import QueueStore
+from ventilatepro.revit_imports import build_revit_import_review
 
 
 class CliTests(unittest.TestCase):
@@ -1181,3 +1182,161 @@ class CliTests(unittest.TestCase):
 
         self.assertEqual(result.exit_code, 0)
         fake_client.design_day_run.assert_called_once_with(1, {"zones": [{"zone_id": 1}]})
+
+    def test_revit_import_review_returns_diff_and_stable_review_token(self):
+        fake_client = mock.Mock()
+        session = {
+            "id": 41,
+            "project": 7,
+            "status": "pending",
+            "updated_at": "2026-07-29T10:00:00Z",
+            "payload": {
+                "rooms": [{"number": "101", "name": "Exam", "revit_space_unique_id": "uid-101"}],
+                "zones": [{"name": "Clinic"}],
+            },
+            "options": {"mark_missing_rooms": True},
+            "diff_summary": {
+                "summary": {
+                    "new_rooms": 1,
+                    "updated_rooms": 0,
+                    "missing_rooms": 2,
+                    "new_zones": 1,
+                    "missing_zones": 0,
+                    "ambiguous_matches": 0,
+                },
+                "new_rooms": [{"key": "revit:uid-101"}],
+                "updated_rooms": [],
+                "missing_rooms": [{"id": 9, "number": "099"}],
+                "new_zones": [{"name": "Clinic"}],
+                "missing_zones": [],
+                "conflicts": {},
+                "errors": [],
+            },
+        }
+        fake_client.revit_import_pending.return_value = session
+
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(
+                app,
+                ["revit-imports", "review", "--project", "7", "--json"],
+            )
+
+        self.assertEqual(result.exit_code, 0)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["summary"]["new_rooms"], 1)
+        self.assertEqual(payload["changes"]["missing_rooms"][0]["id"], 9)
+        self.assertEqual(payload["payload_counts"], {"rooms": 1, "zones": 1})
+        self.assertTrue(payload["review_token"].startswith("revit-import:41:"))
+        self.assertNotIn("payload", payload)
+        fake_client.revit_import_pending.assert_called_once_with(7)
+
+    def test_revit_import_confirm_requires_yes_before_any_api_call(self):
+        fake_client = mock.Mock()
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(
+                app,
+                [
+                    "revit-imports",
+                    "confirm",
+                    "41",
+                    "--project",
+                    "7",
+                    "--review-token",
+                    "revit-import:41:test",
+                ],
+            )
+
+        self.assertNotEqual(result.exit_code, 0)
+        self.assertIn("requires --yes", result.output)
+        fake_client.revit_import_show.assert_not_called()
+        fake_client.revit_import_confirm.assert_not_called()
+
+    def test_revit_import_confirm_rechecks_project_status_and_review_token(self):
+        fake_client = mock.Mock()
+        session = {
+            "id": 41,
+            "project": 7,
+            "status": "pending",
+            "updated_at": "2026-07-29T10:00:00Z",
+            "payload": {
+                "rooms": [{"number": "101", "name": "Exam", "revit_space_unique_id": "uid-101"}],
+                "zones": [],
+            },
+            "options": {},
+            "diff_summary": {"summary": {"new_rooms": 1}},
+        }
+        review_token = build_revit_import_review(session)["review_token"]
+        fake_client.revit_import_show.return_value = session
+        fake_client.revit_import_confirm.return_value = {
+            "session": {"id": 41, "project": 7, "status": "committed"},
+            "result": {"created": 1, "updated": 0, "marked_missing": 0},
+        }
+
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(
+                app,
+                [
+                    "revit-imports",
+                    "confirm",
+                    "41",
+                    "--project",
+                    "7",
+                    "--review-token",
+                    review_token,
+                    "--yes",
+                    "--json",
+                ],
+            )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(json.loads(result.stdout)["session"]["status"], "committed")
+        fake_client.revit_import_show.assert_called_once_with(41)
+        fake_client.revit_import_confirm.assert_called_once_with(41)
+
+    def test_revit_import_confirm_rejects_stale_review_token(self):
+        fake_client = mock.Mock()
+        fake_client.revit_import_show.return_value = {
+            "id": 41,
+            "project": 7,
+            "status": "pending",
+            "updated_at": "2026-07-29T10:05:00Z",
+            "payload": {
+                "rooms": [{"number": "102", "name": "Changed", "revit_space_unique_id": "uid-102"}],
+                "zones": [],
+            },
+            "options": {},
+            "diff_summary": {"summary": {"new_rooms": 1}},
+        }
+
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(
+                app,
+                [
+                    "revit-imports",
+                    "confirm",
+                    "41",
+                    "--project",
+                    "7",
+                    "--review-token",
+                    "revit-import:41:stale",
+                    "--yes",
+                ],
+            )
+
+        self.assertNotEqual(result.exit_code, 0)
+        self.assertIn("changed after it was reviewed", result.output)
+        fake_client.revit_import_confirm.assert_not_called()
+
+    def test_revit_import_api_client_uses_scoped_proxy_and_long_commit_timeout(self):
+        client = ApiClient("https://ventilatepro.example", "token")
+        with mock.patch.object(client, "request", return_value={"status": "ok"}) as request:
+            result = client.revit_import_confirm(41)
+
+        self.assertEqual(result, {"status": "ok"})
+        request.assert_called_once_with(
+            "POST",
+            "/api/cli/proxy/revit-imports/41/commit/",
+            json_payload={},
+            params=None,
+            timeout=300,
+        )

ventilatepro_cli-0.5.0/tests/test_mcp_server.py

@@ -0,0 +1,287 @@
+import asyncio
+import unittest
+from unittest import mock
+
+from ventilatepro.mcp_server import _requires_confirmation, build_server
+
+
+class FakeClient:
+    def __init__(self):
+        self.calls = []
+
+    def schemas(self):
+        return {"schemas": {"api_request": {"description": "ok"}}}
+
+    def schema(self, schema_key):
+        return {"key": schema_key}
+
+    def auth_me(self):
+        return {"username": "agent", "scopes": ["projects:read"]}
+
+    def projects_list(self, *, limit=20, offset=0, query=None):
+        return {"count": 0, "limit": limit, "offset": offset, "query": query, "results": []}
+
+    def cli_proxy(self, method, api_path, *, json_payload=None, params=None):
+        self.calls.append((method, api_path, json_payload, params))
+        return {"method": method, "path": api_path, "payload": json_payload, "params": params}
+
+    def categorization_review(self, project_id):
+        self.calls.append(("categorization_review", project_id))
+        return {
+            "project": {"id": project_id},
+            "category_catalog": {"hcai": [], "occupancy": []},
+            "rooms": [],
+            "categorizations": [],
+        }
+
+    def record_meeting(self, payload):
+        self.calls.append(("record_meeting", payload))
+        return {
+            "meeting": {"id": 31, "title": payload["title"]},
+            "deep_link": "https://ventilatepro.com/?view=meeting-minutes&project=7&minute=31",
+        }
+
+    def revit_import_pending(self, project_id):
+        self.calls.append(("revit_import_pending", project_id))
+        return self.revit_session
+
+    def revit_import_show(self, import_id):
+        self.calls.append(("revit_import_show", import_id))
+        return self.revit_session
+
+    def revit_import_confirm(self, import_id):
+        self.calls.append(("revit_import_confirm", import_id))
+        return {
+            "session": {**self.revit_session, "status": "committed"},
+            "result": {"created": 1},
+        }
+
+    def revit_import_discard(self, import_id):
+        self.calls.append(("revit_import_discard", import_id))
+        return {**self.revit_session, "status": "discarded"}
+
+
+class McpServerTests(unittest.TestCase):
+    def test_tool_catalog_contains_core_tools(self):
+        async def run():
+            server = build_server()
+            tools = await server.list_tools()
+            names = {tool.name for tool in tools}
+            self.assertIn("vp_whoami", names)
+            self.assertIn("vp_api_request", names)
+            self.assertIn("vp_list_entities", names)
+            self.assertIn("vp_run_workflow", names)
+            self.assertIn("vp_get_categorization_review", names)
+            self.assertIn("vp_apply_categorization", names)
+            self.assertIn("vp_get_meeting_context", names)
+            self.assertIn("vp_record_meeting", names)
+            self.assertIn("vp_list_meetings", names)
+            self.assertIn("vp_get_meeting", names)
+            self.assertIn("vp_revise_decision", names)
+            self.assertIn("vp_review_revit_import", names)
+            self.assertIn("vp_confirm_revit_import", names)
+            self.assertIn("vp_discard_revit_import", names)
+
+        asyncio.run(run())
+
+    def test_record_meeting_tool_saves_without_confirmation(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "http://localhost:8000"),
+            ), mock.patch("ventilatepro.mcp_server.QueueStore"):
+                _content, structured = await server.call_tool(
+                    "vp_record_meeting",
+                    {
+                        "project_id": 7,
+                        "idempotency_key": "mcp-meeting-31",
+                        "payload": {
+                            "title": "MCP Coordination",
+                            "started_at": "2026-07-24T09:00:00-07:00",
+                        },
+                    },
+                )
+
+            result = structured["result"]
+            self.assertEqual(result["status"], "created")
+            self.assertEqual(result["meeting"]["id"], 31)
+            sent_payload = fake_client.calls[0][1]
+            self.assertEqual(sent_payload["project_id"], 7)
+            self.assertEqual(sent_payload["idempotency_key"], "mcp-meeting-31")
+
+        asyncio.run(run())
+
+    def test_api_request_tool_uses_cli_proxy(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "http://localhost:8000"),
+            ):
+                _content, structured = await server.call_tool(
+                    "vp_api_request",
+                    {
+                        "method": "GET",
+                        "path": "projects/1/",
+                        "params": {"include": "summary"},
+                    },
+                )
+
+            self.assertEqual(structured["result"]["path"], "projects/1/")
+            self.assertEqual(fake_client.calls[0], ("GET", "projects/1/", None, {"include": "summary"}))
+
+        asyncio.run(run())
+
+    def test_guarded_operations_require_confirmation(self):
+        self.assertTrue(_requires_confirmation("DELETE", "rooms/1/", None))
+        self.assertTrue(_requires_confirmation("POST", "projects/1/recalculate-stale/", {}))
+        self.assertTrue(_requires_confirmation("POST", "projects/1/design-day/run/", {}))
+        self.assertTrue(_requires_confirmation("POST", "projects/1/apply-categorization/", {}))
+        self.assertTrue(_requires_confirmation("PATCH", "projects/1/", {"force": True}))
+        self.assertFalse(_requires_confirmation("GET", "projects/1/", None))
+
+    def test_generic_api_tool_cannot_bypass_revit_review_token(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "http://localhost:8000"),
+            ):
+                _content, structured = await server.call_tool(
+                    "vp_api_request",
+                    {
+                        "method": "POST",
+                        "path": "revit-imports/41/commit/",
+                        "payload": {},
+                        "confirm": True,
+                    },
+                )
+
+            result = structured["result"]
+            self.assertEqual(result["error"]["code"], "specialized_tool_required")
+            self.assertIn("vp_confirm_revit_import", result["error"]["message"])
+            self.assertEqual(fake_client.calls, [])
+
+        asyncio.run(run())
+
+    def test_generic_api_tool_blocks_prefixed_revit_commit_path(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "http://localhost:8000"),
+            ):
+                _content, structured = await server.call_tool(
+                    "vp_api_request",
+                    {
+                        "method": "POST",
+                        "path": "hvac/api/revit-imports/41/commit/",
+                        "payload": {},
+                        "confirm": True,
+                    },
+                )
+
+            self.assertEqual(structured["result"]["error"]["code"], "specialized_tool_required")
+            self.assertEqual(fake_client.calls, [])
+
+        asyncio.run(run())
+
+    def test_revit_import_review_and_confirm_require_matching_review_token(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            fake_client.revit_session = {
+                "id": 41,
+                "project": 7,
+                "status": "pending",
+                "updated_at": "2026-07-29T10:00:00Z",
+                "payload": {
+                    "rooms": [{"number": "101", "name": "Exam", "revit_space_unique_id": "uid-101"}],
+                    "zones": [],
+                },
+                "options": {},
+                "diff_summary": {
+                    "summary": {"new_rooms": 1, "updated_rooms": 0, "missing_rooms": 0},
+                    "new_rooms": [{"key": "revit:uid-101"}],
+                },
+            }
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "http://localhost:8000"),
+            ):
+                _content, structured = await server.call_tool(
+                    "vp_review_revit_import",
+                    {"project_id": 7},
+                )
+                review = structured["result"]
+                self.assertEqual(review["summary"]["new_rooms"], 1)
+                self.assertTrue(review["review_token"].startswith("revit-import:41:"))
+
+                _content, blocked = await server.call_tool(
+                    "vp_confirm_revit_import",
+                    {
+                        "project_id": 7,
+                        "import_id": 41,
+                        "review_token": review["review_token"],
+                        "confirm": False,
+                    },
+                )
+                self.assertEqual(blocked["result"]["error"]["code"], "confirmation_required")
+
+                _content, confirmed = await server.call_tool(
+                    "vp_confirm_revit_import",
+                    {
+                        "project_id": 7,
+                        "import_id": 41,
+                        "review_token": review["review_token"],
+                        "confirm": True,
+                    },
+                )
+
+            self.assertEqual(confirmed["result"]["session"]["status"], "committed")
+            self.assertIn(("revit_import_confirm", 41), fake_client.calls)
+
+        asyncio.run(run())
+
+    def test_revit_import_confirm_rejects_stale_token(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            fake_client.revit_session = {
+                "id": 41,
+                "project": 7,
+                "status": "pending",
+                "updated_at": "2026-07-29T10:05:00Z",
+                "payload": {"rooms": [{"number": "102", "name": "Changed"}], "zones": []},
+                "options": {},
+                "diff_summary": {"summary": {"new_rooms": 1}},
+            }
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "http://localhost:8000"),
+            ):
+                _content, structured = await server.call_tool(
+                    "vp_confirm_revit_import",
+                    {
+                        "project_id": 7,
+                        "import_id": 41,
+                        "review_token": "revit-import:41:stale",
+                        "confirm": True,
+                    },
+                )
+
+            result = structured["result"]
+            self.assertEqual(result["error"]["code"], "ValueError")
+            self.assertIn("changed after it was reviewed", result["error"]["message"])
+            self.assertNotIn(("revit_import_confirm", 41), fake_client.calls)
+
+        asyncio.run(run())
+
+
+if __name__ == "__main__":
+    unittest.main()

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/ventilatepro/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/ventilatepro/api_client.py

@@ -149,12 +149,14 @@ class ApiClient:
         *,
         json_payload: Optional[Dict[str, Any]] = None,
         params: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = None,
     ):
         return self.request(
             method.upper(),
             self._proxy_path(api_path),
             json_payload=json_payload,
             params=params,
+            timeout=timeout,
         )
 
     def cli_proxy_download(
@@ -245,6 +247,27 @@ class ApiClient:
             timeout=300,
         )
 
+    def revit_import_pending(self, project_id: int):
+        return self.cli_proxy("GET", f"projects/{project_id}/revit-imports/pending/")
+
+    def revit_import_show(self, import_id: int):
+        return self.cli_proxy("GET", f"revit-imports/{import_id}/")
+
+    def revit_import_confirm(self, import_id: int):
+        return self.cli_proxy(
+            "POST",
+            f"revit-imports/{import_id}/commit/",
+            json_payload={},
+            timeout=300,
+        )
+
+    def revit_import_discard(self, import_id: int):
+        return self.cli_proxy(
+            "POST",
+            f"revit-imports/{import_id}/discard/",
+            json_payload={},
+        )
+
     def _list_project_entities(
         self,
         entity_name: str,

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/ventilatepro/cli.py

@@ -22,6 +22,7 @@ from .output import emit, emit_error
 from .payloads import require_confirmation
 from .projects import app as projects_app
 from .queue import QueueStore
+from .revit_imports import app as revit_imports_app
 from .systems import app as systems_app
 
 app = typer.Typer(help="VentilatePro CLI")
@@ -40,6 +41,7 @@ app.add_typer(plants_app, name="plants")
 app.add_typer(systems_app, name="systems")
 app.add_typer(calc_app, name="calc")
 app.add_typer(categorization_app, name="categorization")
+app.add_typer(revit_imports_app, name="revit-imports")
 app.add_typer(design_day_app, name="design-day")
 app.add_typer(notes_app, name="notes")
 app.add_typer(meetings_app, name="meetings")

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/ventilatepro/mcp_server.py

@@ -11,6 +11,11 @@ from . import meetings
 from .api_client import ApiError, NetworkError
 from .categorization import _validate_apply_manifest
 from .queue import QueueStore
+from .revit_imports import (
+    build_revit_import_review,
+    get_revit_import_session,
+    require_matching_review_token,
+)
 
 try:
     from mcp.server.fastmcp import FastMCP
@@ -91,8 +96,6 @@ WORKFLOW_PATHS = {
     "gbxml_commit": "projects/{project_id}/commit-gbxml/",
     "revit_import_pending": "projects/{project_id}/revit-imports/pending/",
     "revit_import_detail": "revit-imports/{import_id}/",
-    "revit_import_commit": "revit-imports/{import_id}/commit/",
-    "revit_import_discard": "revit-imports/{import_id}/discard/",
     "qc_list": "projects/{project_id}/qc/",
     "qc_detail": "projects/{project_id}/qc/{report_id}/",
     "revit_qc_runs": "projects/{project_id}/revit-qc/runs/",
@@ -115,6 +118,11 @@ CAPABILITIES = {
         "meeting_show",
         "decision_revise",
     ],
+    "revit_import_tools": [
+        "vp_review_revit_import",
+        "vp_confirm_revit_import",
+        "vp_discard_revit_import",
+    ],
     "resources": [
         "ventilatepro://auth/me",
         "ventilatepro://projects",
@@ -122,6 +130,7 @@ CAPABILITIES = {
         "ventilatepro://projects/{project_id}/hierarchy",
         "ventilatepro://projects/{project_id}/system-graph",
         "ventilatepro://projects/{project_id}/system-topology",
+        "ventilatepro://projects/{project_id}/revit-imports/pending",
         "ventilatepro://projects/{project_id}/categorization/review",
         "ventilatepro://schemas/{schema_key}",
     ],
@@ -204,6 +213,23 @@ def _call_api(
     try:
         normalized_method = _normalize_method(method)
         normalized_path = _normalize_path(path)
+        path_parts = normalized_path.strip("/").lower().split("/")
+        if (
+            normalized_method != "GET"
+            and len(path_parts) >= 3
+            and "revit-imports" in path_parts
+            and path_parts[-1] in {"commit", "discard"}
+        ):
+            tool_name = (
+                "vp_confirm_revit_import"
+                if path_parts[-1] == "commit"
+                else "vp_discard_revit_import"
+            )
+            return _error_payload(
+                "specialized_tool_required",
+                f"Use {tool_name} for this Revit import operation.",
+                detail={"method": normalized_method, "path": normalized_path},
+            )
         if _requires_confirmation(normalized_method, normalized_path, payload) and not confirm:
             return _error_payload(
                 "confirmation_required",
@@ -307,7 +333,8 @@ def build_server():
         "VentilatePro",
         instructions=(
             "Operate VentilatePro through scoped backend APIs. Use confirm=true only after the user has "
-            "approved destructive, broad, import, export, apply, or run operations."
+            "approved destructive, broad, import, export, apply, or run operations. For Revit imports, call "
+            "vp_review_revit_import first and confirm only with its unchanged review_token."
         ),
     )
 
@@ -508,6 +535,77 @@ def build_server():
             detail = getattr(exc, "payload", None)
             return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
 
+    @server.tool()
+    def vp_review_revit_import(
+        project_id: int,
+        import_id: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Review the pending or selected Revit import diff without changing project data."""
+        try:
+            client = _client()
+            session = get_revit_import_session(
+                client,
+                project_id=project_id,
+                import_id=import_id,
+            )
+            return build_revit_import_review(session)
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
+    @server.tool()
+    def vp_confirm_revit_import(
+        project_id: int,
+        import_id: int,
+        review_token: str,
+        confirm: bool = False,
+    ) -> Dict[str, Any]:
+        """Commit the exact reviewed Revit import revision. Requires its review token and confirm=true."""
+        if not confirm:
+            return _error_payload(
+                "confirmation_required",
+                "Confirming a Revit import requires confirm=true after the import review is presented to the user.",
+            )
+        try:
+            client = _client()
+            session = get_revit_import_session(
+                client,
+                project_id=project_id,
+                import_id=import_id,
+                require_pending=True,
+            )
+            review = build_revit_import_review(session)
+            require_matching_review_token(review, review_token)
+            return client.revit_import_confirm(import_id)
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
+    @server.tool()
+    def vp_discard_revit_import(
+        project_id: int,
+        import_id: int,
+        confirm: bool = False,
+    ) -> Dict[str, Any]:
+        """Discard a pending Revit import without applying it. Requires confirm=true."""
+        if not confirm:
+            return _error_payload(
+                "confirmation_required",
+                "Discarding a Revit import requires confirm=true.",
+            )
+        try:
+            client = _client()
+            get_revit_import_session(
+                client,
+                project_id=project_id,
+                import_id=import_id,
+                require_pending=True,
+            )
+            return client.revit_import_discard(import_id)
+        except (ValueError, ApiError, NetworkError) as exc:
+            detail = getattr(exc, "payload", None)
+            return _error_payload(exc.__class__.__name__, str(exc), detail=detail)
+
     @server.tool()
     def vp_list_entities(
         entity: str,
@@ -615,6 +713,10 @@ def build_server():
     def resource_categorization_review(project_id: int) -> str:
         return _json_resource(vp_get_categorization_review(project_id))
 
+    @server.resource("ventilatepro://projects/{project_id}/revit-imports/pending")
+    def resource_pending_revit_import(project_id: int) -> str:
+        return _json_resource(vp_review_revit_import(project_id))
+
     @server.resource("ventilatepro://projects/{project_id}")
     def resource_project(project_id: str) -> str:
         return _json_resource(vp_get_project(int(project_id)))
@@ -666,6 +768,15 @@ def build_server():
             "notes, and schedules. Prioritize findings by risk and identify concrete model or schedule edits."
         )
 
+    @server.prompt()
+    def revit_import_review(project_id: int) -> str:
+        return (
+            f"Review the pending Revit import for VentilatePro project {project_id}. Use vp_review_revit_import, "
+            "summarize room and zone changes plus every conflict, and do not commit it until the user approves the "
+            "review. After approval, pass the unchanged review_token to vp_confirm_revit_import with confirm=true. "
+            "If the token is stale, review the import again before requesting approval."
+        )
+
     @server.prompt()
     def controls_package_draft(project_id: int) -> str:
         return (

ventilatepro_cli-0.5.0/ventilatepro/revit_imports.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import secrets
+from typing import Any, Dict, Optional
+
+import typer
+
+from . import auth
+from .api_client import ApiError, NetworkError
+from .output import emit, emit_error
+from .payloads import require_confirmation
+
+app = typer.Typer(help="Review and confirm staged Revit imports")
+
+
+def _session_project_id(session: Dict[str, Any]) -> Optional[int]:
+    project = session.get("project")
+    if isinstance(project, dict):
+        project = project.get("id")
+    try:
+        return int(project)
+    except (TypeError, ValueError):
+        return None
+
+
+def validate_revit_import_session(
+    session: Dict[str, Any],
+    *,
+    project_id: int,
+    require_pending: bool = False,
+) -> Dict[str, Any]:
+    if not isinstance(session, dict):
+        raise ValueError("The Revit import response was not a JSON object.")
+    actual_project_id = _session_project_id(session)
+    if actual_project_id != project_id:
+        raise ValueError(
+            f"Revit import {session.get('id')} belongs to project {actual_project_id}, "
+            f"not project {project_id}."
+        )
+    if require_pending and session.get("status") != "pending":
+        raise ValueError(
+            f"Revit import {session.get('id')} is {session.get('status') or 'not pending'}; "
+            "only pending imports can be confirmed."
+        )
+    return session
+
+
+def get_revit_import_session(
+    client,
+    *,
+    project_id: int,
+    import_id: Optional[int] = None,
+    require_pending: bool = False,
+) -> Dict[str, Any]:
+    if import_id is None:
+        session = client.revit_import_pending(project_id)
+    else:
+        session = client.revit_import_show(import_id)
+    return validate_revit_import_session(
+        session,
+        project_id=project_id,
+        require_pending=require_pending,
+    )
+
+
+def _review_token(session: Dict[str, Any]) -> str:
+    snapshot = {
+        "id": session.get("id"),
+        "project": _session_project_id(session),
+        "status": session.get("status"),
+        "updated_at": session.get("updated_at"),
+        "payload": session.get("payload") or {},
+        "options": session.get("options") or {},
+        "diff_summary": session.get("diff_summary") or {},
+    }
+    canonical = json.dumps(
+        snapshot,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        default=str,
+    ).encode("utf-8")
+    return f"revit-import:{session.get('id')}:{hashlib.sha256(canonical).hexdigest()}"
+
+
+def build_revit_import_review(session: Dict[str, Any]) -> Dict[str, Any]:
+    diff = session.get("diff_summary") or {}
+    payload = session.get("payload") or {}
+    rooms = payload.get("rooms") or []
+    zones = payload.get("zones") or []
+    return {
+        "id": session.get("id"),
+        "project": _session_project_id(session),
+        "status": session.get("status"),
+        "created_by": session.get("created_by"),
+        "created_by_name": session.get("created_by_name"),
+        "created_at": session.get("created_at"),
+        "updated_at": session.get("updated_at"),
+        "metadata": session.get("metadata") or {},
+        "options": session.get("options") or {},
+        "payload_counts": {
+            "rooms": len(rooms),
+            "zones": len(zones),
+        },
+        "summary": diff.get("summary") or {},
+        "changes": {
+            "new_rooms": diff.get("new_rooms") or [],
+            "updated_rooms": diff.get("updated_rooms") or [],
+            "missing_rooms": diff.get("missing_rooms") or diff.get("deleted_rooms") or [],
+            "new_zones": diff.get("new_zones") or [],
+            "missing_zones": diff.get("missing_zones") or diff.get("deleted_zones") or [],
+        },
+        "conflicts": diff.get("conflicts") or {},
+        "errors": diff.get("errors") or [],
+        "review_token": _review_token(session),
+    }
+
+
+def require_matching_review_token(review: Dict[str, Any], supplied_token: str) -> None:
+    expected_token = str(review.get("review_token") or "")
+    if not supplied_token:
+        raise ValueError("Confirming a Revit import requires the review_token from a fresh review.")
+    if not secrets.compare_digest(expected_token, supplied_token):
+        raise ValueError(
+            "The Revit import changed after it was reviewed. Review it again and use the new review_token."
+        )
+
+
+def review_lines(review: Dict[str, Any]) -> list[str]:
+    summary = review.get("summary") or {}
+    counts = review.get("payload_counts") or {}
+    issue_keys = (
+        "duplicate_room_keys",
+        "duplicate_stable_ids",
+        "duplicate_room_labels",
+        "missing_identifiers",
+        "existing_duplicates",
+        "ambiguous_matches",
+    )
+    issue_count = sum(int(summary.get(key) or 0) for key in issue_keys)
+    return [
+        f"Revit import: {review.get('id')} ({review.get('status')})",
+        f"Project: {review.get('project')}",
+        f"Payload: {counts.get('rooms', 0)} rooms, {counts.get('zones', 0)} zones",
+        (
+            "Room changes: "
+            f"{summary.get('new_rooms', 0)} new, "
+            f"{summary.get('updated_rooms', 0)} updated, "
+            f"{summary.get('missing_rooms', summary.get('deleted_rooms', 0))} missing"
+        ),
+        (
+            "Zone changes: "
+            f"{summary.get('new_zones', 0)} new, "
+            f"{summary.get('missing_zones', summary.get('deleted_zones', 0))} missing"
+        ),
+        f"Review issues: {issue_count}",
+        f"Review token: {review.get('review_token')}",
+    ]
+
+
+@app.command("review")
+def revit_import_review(
+    project: int = typer.Option(..., "--project", help="Target project ID"),
+    import_id: int = typer.Option(None, "--import", help="Specific import ID; defaults to the pending import"),
+    json_output: bool = typer.Option(False, "--json", help="Return the machine-readable review artifact"),
+):
+    """Review a pending or historical Revit import without changing project data."""
+    try:
+        client, _ = auth.get_authenticated_client()
+        session = get_revit_import_session(
+            client,
+            project_id=project,
+            import_id=import_id,
+        )
+        review = build_revit_import_review(session)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+    emit(review, json_output=json_output, lines=review_lines(review))
+
+
+@app.command("show")
+def revit_import_show(
+    import_id: int = typer.Argument(..., help="Revit import ID"),
+    project: int = typer.Option(..., "--project", help="Expected project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return the full import session including its payload"),
+):
+    """Show the full staged import payload and computed diff."""
+    try:
+        client, _ = auth.get_authenticated_client()
+        session = get_revit_import_session(
+            client,
+            project_id=project,
+            import_id=import_id,
+        )
+        review = build_revit_import_review(session)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+    emit(session, json_output=json_output, lines=review_lines(review))
+
+
+@app.command("confirm")
+def revit_import_confirm(
+    import_id: int = typer.Argument(..., help="Pending Revit import ID"),
+    project: int = typer.Option(..., "--project", help="Expected project ID"),
+    review_token: str = typer.Option(..., "--review-token", help="Token returned by a fresh review"),
+    yes: bool = typer.Option(False, "--yes", help="Confirm applying the staged Revit import"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    """Commit the exact import revision that was reviewed."""
+    try:
+        require_confirmation(yes=yes, action="Confirming a Revit import")
+        client, _ = auth.get_authenticated_client()
+        session = get_revit_import_session(
+            client,
+            project_id=project,
+            import_id=import_id,
+            require_pending=True,
+        )
+        review = build_revit_import_review(session)
+        require_matching_review_token(review, review_token)
+        result = client.revit_import_confirm(import_id)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    committed_session = result.get("session") or {}
+    import_result = result.get("result") or {}
+    emit(
+        result,
+        json_output=json_output,
+        lines=[
+            f"Committed Revit import {committed_session.get('id', import_id)} for project {project}.",
+            (
+                "Rooms: "
+                f"{import_result.get('created', 0)} created, "
+                f"{import_result.get('updated', 0)} updated, "
+                f"{import_result.get('marked_missing', 0)} marked missing"
+            ),
+        ],
+    )
+
+
+@app.command("discard")
+def revit_import_discard(
+    import_id: int = typer.Argument(..., help="Pending Revit import ID"),
+    project: int = typer.Option(..., "--project", help="Expected project ID"),
+    yes: bool = typer.Option(False, "--yes", help="Confirm discarding the staged import"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    """Discard a pending import without applying it."""
+    try:
+        require_confirmation(yes=yes, action="Discarding a Revit import")
+        client, _ = auth.get_authenticated_client()
+        get_revit_import_session(
+            client,
+            project_id=project,
+            import_id=import_id,
+            require_pending=True,
+        )
+        result = client.revit_import_discard(import_id)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    emit(
+        result,
+        json_output=json_output,
+        lines=[f"Discarded Revit import {result.get('id', import_id)} for project {project}."],
+    )

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/ventilatepro_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventilatepro-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: VentilatePro CLI
 Project-URL: Homepage, https://ventilatepro.com/exam/cli/
 Project-URL: Documentation, https://ventilatepro.com/exam/cli/
@@ -47,6 +47,8 @@ ventilatepro projects show 1
 ventilatepro rooms list --project 1
 ventilatepro room-equipment summary --project 1
 ventilatepro room-equipment create --data '{"room": 501, "name": "Sterilizer", "heat_gain_value": 1.8, "heat_gain_unit": "KW"}'
+ventilatepro revit-imports review --project 1 --json
+ventilatepro revit-imports confirm 41 --project 1 --review-token <token-from-review> --yes
 ventilatepro categorization review --project 1 --output room-categorization.json
 ventilatepro categorization apply --project 1 --input room-categorization.json --yes
 ventilatepro ahus list --project 1
@@ -77,6 +79,11 @@ review resource or use the dedicated MCP tools. Review manifests default every
 room to rejected so ambiguous spaces remain visible until a category is
 explicitly accepted with a reason.
 
+For staged Revit imports, agents use `revit-imports review` or
+`vp_review_revit_import` first. The returned review token identifies the exact
+payload and diff that was inspected. Confirmation requires that unchanged token
+plus explicit `--yes` or MCP `confirm=true`; stale reviews are rejected.
+
 ## MCP setup
 
 1. In the VentilatePro web app, open Account Settings and create a CLI token with

{ventilatepro_cli-0.4.0 → ventilatepro_cli-0.5.0}/ventilatepro_cli.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ ventilatepro/output.py
 ventilatepro/payloads.py
 ventilatepro/projects.py
 ventilatepro/queue.py
+ventilatepro/revit_imports.py
 ventilatepro/systems.py
 ventilatepro_cli.egg-info/PKG-INFO
 ventilatepro_cli.egg-info/SOURCES.txt

ventilatepro_cli-0.4.0/tests/test_mcp_server.py

@@ -1,126 +0,0 @@
-import asyncio
-import unittest
-from unittest import mock
-
-from ventilatepro.mcp_server import _requires_confirmation, build_server
-
-
-class FakeClient:
-    def __init__(self):
-        self.calls = []
-
-    def schemas(self):
-        return {"schemas": {"api_request": {"description": "ok"}}}
-
-    def schema(self, schema_key):
-        return {"key": schema_key}
-
-    def auth_me(self):
-        return {"username": "agent", "scopes": ["projects:read"]}
-
-    def projects_list(self, *, limit=20, offset=0, query=None):
-        return {"count": 0, "limit": limit, "offset": offset, "query": query, "results": []}
-
-    def cli_proxy(self, method, api_path, *, json_payload=None, params=None):
-        self.calls.append((method, api_path, json_payload, params))
-        return {"method": method, "path": api_path, "payload": json_payload, "params": params}
-
-    def categorization_review(self, project_id):
-        self.calls.append(("categorization_review", project_id))
-        return {
-            "project": {"id": project_id},
-            "category_catalog": {"hcai": [], "occupancy": []},
-            "rooms": [],
-            "categorizations": [],
-        }
-
-    def record_meeting(self, payload):
-        self.calls.append(("record_meeting", payload))
-        return {
-            "meeting": {"id": 31, "title": payload["title"]},
-            "deep_link": "https://ventilatepro.com/?view=meeting-minutes&project=7&minute=31",
-        }
-
-
-class McpServerTests(unittest.TestCase):
-    def test_tool_catalog_contains_core_tools(self):
-        async def run():
-            server = build_server()
-            tools = await server.list_tools()
-            names = {tool.name for tool in tools}
-            self.assertIn("vp_whoami", names)
-            self.assertIn("vp_api_request", names)
-            self.assertIn("vp_list_entities", names)
-            self.assertIn("vp_run_workflow", names)
-            self.assertIn("vp_get_categorization_review", names)
-            self.assertIn("vp_apply_categorization", names)
-            self.assertIn("vp_get_meeting_context", names)
-            self.assertIn("vp_record_meeting", names)
-            self.assertIn("vp_list_meetings", names)
-            self.assertIn("vp_get_meeting", names)
-            self.assertIn("vp_revise_decision", names)
-
-        asyncio.run(run())
-
-    def test_record_meeting_tool_saves_without_confirmation(self):
-        async def run():
-            server = build_server()
-            fake_client = FakeClient()
-            with mock.patch(
-                "ventilatepro.mcp_server.auth.get_authenticated_client",
-                return_value=(fake_client, "http://localhost:8000"),
-            ), mock.patch("ventilatepro.mcp_server.QueueStore"):
-                _content, structured = await server.call_tool(
-                    "vp_record_meeting",
-                    {
-                        "project_id": 7,
-                        "idempotency_key": "mcp-meeting-31",
-                        "payload": {
-                            "title": "MCP Coordination",
-                            "started_at": "2026-07-24T09:00:00-07:00",
-                        },
-                    },
-                )
-
-            result = structured["result"]
-            self.assertEqual(result["status"], "created")
-            self.assertEqual(result["meeting"]["id"], 31)
-            sent_payload = fake_client.calls[0][1]
-            self.assertEqual(sent_payload["project_id"], 7)
-            self.assertEqual(sent_payload["idempotency_key"], "mcp-meeting-31")
-
-        asyncio.run(run())
-
-    def test_api_request_tool_uses_cli_proxy(self):
-        async def run():
-            server = build_server()
-            fake_client = FakeClient()
-            with mock.patch(
-                "ventilatepro.mcp_server.auth.get_authenticated_client",
-                return_value=(fake_client, "http://localhost:8000"),
-            ):
-                _content, structured = await server.call_tool(
-                    "vp_api_request",
-                    {
-                        "method": "GET",
-                        "path": "projects/1/",
-                        "params": {"include": "summary"},
-                    },
-                )
-
-            self.assertEqual(structured["result"]["path"], "projects/1/")
-            self.assertEqual(fake_client.calls[0], ("GET", "projects/1/", None, {"include": "summary"}))
-
-        asyncio.run(run())
-
-    def test_guarded_operations_require_confirmation(self):
-        self.assertTrue(_requires_confirmation("DELETE", "rooms/1/", None))
-        self.assertTrue(_requires_confirmation("POST", "projects/1/recalculate-stale/", {}))
-        self.assertTrue(_requires_confirmation("POST", "projects/1/design-day/run/", {}))
-        self.assertTrue(_requires_confirmation("POST", "projects/1/apply-categorization/", {}))
-        self.assertTrue(_requires_confirmation("PATCH", "projects/1/", {"force": True}))
-        self.assertFalse(_requires_confirmation("GET", "projects/1/", None))
-
-
-if __name__ == "__main__":
-    unittest.main()