pi-revit 0.2.4 → 0.2.6

package/CHANGELOG.md

@@ -7,6 +7,40 @@ Format follows [Keep a Changelog](https://keepachangelog.com/); version headers
 Every published version gets an entry with **Added** / **Changed** / **Fixed** sections
 describing what the user will notice — not internal refactors.
 
+## [0.2.6] - 2026-07-20
+
+### Fixed
+- Write transactions (`set_parameters`, `execute_csharp`, and the temporary-isolate
+  branch of `manage_selection`) now register a failures preprocessor. Previously Revit
+  handled commit failures interactively: warnings popped the transient toast and spammed
+  the journal, and an error-severity failure showed the modal resolution dialog, blocking
+  the bridge until a human clicked. Now warnings are auto-dismissed and reported back
+  (`commitWarnings` in the result, e.g. duplicate Mark values), and errors roll the
+  transaction back with the actual Revit failure text in the error message.
+
+### Changed
+- `set_parameters` tool description tells the model to relay `commitWarnings` to the user.
+
+Requires redeploying the Revit add-in (`scripts\deploy.ps1` + Revit restart).
+
+## [0.2.5] - 2026-07-20
+
+### Fixed
+- `execute_csharp` dialog guard no longer answers every Revit popup with OK. On some
+  dialogs OK is the destructive choice (e.g. "Delete Element(s)"), so a script could
+  silently delete dimensions or constraints and still report success. Unrecognized
+  dialogs are now answered dismissively (Cancel, then Close, then No; OK only as the
+  last resort so Revit can never hang behind a popup), a small allowlist keeps OK for
+  dialogs that are safe to confirm, and `suppressedDialogs` now reports which answer
+  was given (e.g. `TaskDialog_… (answered Cancel)`).
+
+### Changed
+- The `execute_csharp` tool description tells the model that confirmation prompts may be
+  cancelled and to check `suppressedDialogs` when a result looks incomplete.
+
+Requires redeploying the Revit add-in (`scripts\deploy.ps1` + Revit restart) — `ping`
+warns on a version mismatch until then.
+
 ## [0.2.4] - 2026-07-20
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-revit",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Native Pi connector for Autodesk Revit. Run npx.cmd -y pi-revit for the full Windows install.",
   "author": "Ahmad Altahlawi",
   "license": "MIT",

package/src/Revit/Tools/ExecuteCsharp.cs

@@ -59,7 +59,7 @@ namespace RevitBridge.Tools
 
         public string Name => "execute_csharp";
         public string Label => "Execute C#";
-        public string Description => "Compile and run a C# script on the Revit API thread against the open model — the escape hatch for anything without a dedicated tool: element creation, deletion, geometry edits (move/copy/rotate), views, sheets, schedules, tagging, families, links, worksets. Globals: doc (Document), uidoc (UIDocument), uiapp (UIApplication), and Dump(value) to record intermediate values into the result's dumps[]. Default imports: System, System.Linq, System.Collections.Generic, Autodesk.Revit.DB, Autodesk.Revit.UI — add using directives at the top for sub-namespaces (e.g. using Autodesk.Revit.DB.Architecture;). The entire run is wrapped in ONE transaction named 'execute_csharp': committed on success, rolled back on any exception, so a failed script never changes the model (do not open your own Transaction; sub-transactions are fine). The script's final expression or return statement becomes returnValue; return primitives, strings, or anonymous objects/lists — Revit API values are projected to safe shapes (Element -> {id,name,category,typeName,levelId}, ElementId -> number, XYZ -> {x,y,z}, Parameter -> {name,value,displayValue}; other API objects become strings) with depth and item caps, so never rely on raw API objects round-tripping. Lengths are in internal units (decimal feet) — convert with UnitUtils. Prefer collector-level filtering (FilteredElementCollector .OfCategory/.OfClass/.WhereElementIsNotElementType) and bounded loops: the call budget is 120s and Revit cannot be interrupted mid-script. Scripts must be fully synchronous — await/async is rejected at compile time, and blocking on tasks (Task.Result/.Wait()) can freeze Revit. Modal dialogs raised while running are auto-dismissed and reported in suppressedDialogs. Verify unfamiliar signatures with search_api_docs first.";
+        public string Description => "Compile and run a C# script on the Revit API thread against the open model — the escape hatch for anything without a dedicated tool: element creation, deletion, geometry edits (move/copy/rotate), views, sheets, schedules, tagging, families, links, worksets. Globals: doc (Document), uidoc (UIDocument), uiapp (UIApplication), and Dump(value) to record intermediate values into the result's dumps[]. Default imports: System, System.Linq, System.Collections.Generic, Autodesk.Revit.DB, Autodesk.Revit.UI — add using directives at the top for sub-namespaces (e.g. using Autodesk.Revit.DB.Architecture;). The entire run is wrapped in ONE transaction named 'execute_csharp': committed on success, rolled back on any exception, so a failed script never changes the model (do not open your own Transaction; sub-transactions are fine). The script's final expression or return statement becomes returnValue; return primitives, strings, or anonymous objects/lists — Revit API values are projected to safe shapes (Element -> {id,name,category,typeName,levelId}, ElementId -> number, XYZ -> {x,y,z}, Parameter -> {name,value,displayValue}; other API objects become strings) with depth and item caps, so never rely on raw API objects round-tripping. Lengths are in internal units (decimal feet) — convert with UnitUtils. Prefer collector-level filtering (FilteredElementCollector .OfCategory/.OfClass/.WhereElementIsNotElementType) and bounded loops: the call budget is 120s and Revit cannot be interrupted mid-script. Scripts must be fully synchronous — await/async is rejected at compile time, and blocking on tasks (Task.Result/.Wait()) can freeze Revit. Modal dialogs raised while running are auto-dismissed and reported in suppressedDialogs — unrecognized dialogs are answered dismissively (Cancel/Close/No) rather than confirmed, so an operation that raises a confirmation prompt may be cancelled; check suppressedDialogs when a result looks incomplete. Verify unfamiliar signatures with search_api_docs first.";
         public bool Write => true;
 
         public object ParametersSchema => new
@@ -113,6 +113,7 @@ namespace RevitBridge.Tools
 
             using var dialogGuard = new DialogGuard(uiapp);
             using var transaction = new Transaction(doc, "execute_csharp");
+            var failureGuard = FailureGuard.Attach(transaction);
             if (transaction.Start() != TransactionStatus.Started)
                 throw new InvalidOperationException("Unable to start the execute_csharp transaction.");
 
@@ -142,6 +143,7 @@ namespace RevitBridge.Tools
             if (transaction.Commit() != TransactionStatus.Committed)
                 throw new InvalidOperationException(
                     "Revit rolled back the execute_csharp transaction during commit (failure processing rejected the changes); no model changes were saved."
+                    + failureGuard.DescribeErrors()
                     + DescribeDialogs(dialogGuard.Suppressed));
 
             stopwatch.Stop();
@@ -154,6 +156,8 @@ namespace RevitBridge.Tools
             };
             if (dialogGuard.Suppressed.Count > 0)
                 payload["suppressedDialogs"] = dialogGuard.Suppressed;
+            if (failureGuard.Warnings.Count > 0)
+                payload["commitWarnings"] = failureGuard.Warnings;
             return payload;
         }
 
@@ -234,9 +238,31 @@ namespace RevitBridge.Tools
         }
 
         /// <summary>Auto-dismisses any modal Revit dialog raised while the script runs, so a
-        /// popup cannot hang the Revit thread; dismissed dialog ids are reported.</summary>
+        /// popup cannot hang the Revit thread; dismissed dialog ids and the answer given are
+        /// reported. Unrecognized dialogs get the dismissive answer (Cancel, then Close, then
+        /// No) — on several Revit dialogs OK is the destructive choice (e.g. "Delete
+        /// Element(s)"), so confirming blind can silently damage the model. OK leads only for
+        /// dialogs known to be safe to confirm, and is otherwise the last resort: every
+        /// override attempt failing would leave the dialog up and hang the Revit thread,
+        /// which is the one outcome this guard exists to prevent.</summary>
         private sealed class DialogGuard : IDisposable
         {
+            private const int IDOK = 1;
+            private const int IDCANCEL = 2;
+            private const int IDNO = 7;
+            private const int IDCLOSE = 8;
+
+            /// <summary>Dialogs where confirming is the benign answer and cancelling would
+            /// abort the operation the script deliberately started.</summary>
+            private static readonly HashSet<string> ConfirmSafeDialogIds = new(StringComparer.OrdinalIgnoreCase)
+            {
+                // "Export with temporary hide/isolate": OK exports the view as displayed.
+                "TaskDialog_Really_Print_Or_Export_Temp_View_Modes",
+            };
+
+            private static readonly int[] ConfirmFirst = { IDOK, IDCANCEL, IDCLOSE };
+            private static readonly int[] DismissFirst = { IDCANCEL, IDCLOSE, IDNO, IDOK };
+
             private readonly UIApplication _uiapp;
             public List<string> Suppressed { get; } = new();
 
@@ -248,17 +274,35 @@ namespace RevitBridge.Tools
 
             private void OnDialogBoxShowing(object? sender, DialogBoxShowingEventArgs e)
             {
-                Suppressed.Add(string.IsNullOrEmpty(e.DialogId) ? e.GetType().Name : e.DialogId);
-                try
-                {
-                    e.OverrideResult(1); // IDOK
-                }
-                catch
+                string id = string.IsNullOrEmpty(e.DialogId) ? e.GetType().Name : e.DialogId;
+                int[] answers = ConfirmSafeDialogIds.Contains(id) ? ConfirmFirst : DismissFirst;
+                foreach (int answer in answers)
                 {
-                    // Some dialogs reject overrides; never let the guard itself throw.
+                    try
+                    {
+                        if (e.OverrideResult(answer))
+                        {
+                            Suppressed.Add($"{id} (answered {AnswerName(answer)})");
+                            return;
+                        }
+                    }
+                    catch
+                    {
+                        // Some dialogs reject specific overrides; try the next answer.
+                    }
                 }
+                Suppressed.Add($"{id} (override rejected — dialog may need manual dismissal)");
             }
 
+            private static string AnswerName(int answer) => answer switch
+            {
+                IDOK => "OK",
+                IDCANCEL => "Cancel",
+                IDNO => "No",
+                IDCLOSE => "Close",
+                _ => answer.ToString(),
+            };
+
             public void Dispose()
             {
                 try

package/src/Revit/Tools/FailureGuard.cs

@@ -0,0 +1,62 @@
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    /// <summary>
+    /// Deterministic commit-time failure handling for tool-owned transactions. Without a
+    /// preprocessor, Revit resolves commit failures interactively: warnings pop the
+    /// transient toast (and spam the journal), and error-severity failures block the
+    /// Revit API thread behind the modal resolution dialog until a human clicks — past
+    /// the bridge's call budget. Attach() deletes warnings (recorded for the tool
+    /// result) and turns errors into a rollback, so a headless caller always gets an
+    /// answer instead of a hang.
+    /// </summary>
+    internal sealed class FailureGuard : IFailuresPreprocessor
+    {
+        public List<string> Warnings { get; } = new();
+        public List<string> Errors { get; } = new();
+
+        public static FailureGuard Attach(Transaction transaction)
+        {
+            var guard = new FailureGuard();
+            var options = transaction.GetFailureHandlingOptions();
+            options.SetFailuresPreprocessor(guard);
+            options.SetClearAfterRollback(true);
+            transaction.SetFailureHandlingOptions(options);
+            return guard;
+        }
+
+        public FailureProcessingResult PreprocessFailures(FailuresAccessor accessor)
+        {
+            bool hasError = false;
+            foreach (FailureMessageAccessor failure in accessor.GetFailureMessages())
+            {
+                string description;
+                try
+                {
+                    description = failure.GetDescriptionText();
+                }
+                catch
+                {
+                    description = "(failure without description)";
+                }
+
+                if (failure.GetSeverity() == FailureSeverity.Warning)
+                {
+                    Warnings.Add(description);
+                    accessor.DeleteWarning(failure);
+                }
+                else
+                {
+                    hasError = true;
+                    Errors.Add(description);
+                }
+            }
+            return hasError ? FailureProcessingResult.ProceedWithRollBack : FailureProcessingResult.Continue;
+        }
+
+        /// <summary>Formats the recorded errors for a commit-failure message.</summary>
+        public string DescribeErrors()
+            => Errors.Count > 0 ? $" Revit failure(s): {string.Join("; ", Errors)}." : string.Empty;
+    }
+}

package/src/Revit/Tools/ManageSelection.cs

@@ -192,6 +192,7 @@ namespace RevitBridge.Tools
         private static void ApplyTemporaryIsolate(Document doc, View view, ICollection<ElementId> elementIds)
         {
             using var transaction = new Transaction(doc, "manage_selection: temporary isolate");
+            var failureGuard = FailureGuard.Attach(transaction);
             if (transaction.Start() != TransactionStatus.Started)
                 throw new InvalidOperationException("Unable to start the temporary-isolate transaction.");
             try
@@ -201,7 +202,7 @@ namespace RevitBridge.Tools
                 else
                     view.IsolateElementsTemporary(elementIds);
                 if (transaction.Commit() != TransactionStatus.Committed)
-                    throw new InvalidOperationException("The temporary-isolate transaction failed to commit.");
+                    throw new InvalidOperationException("The temporary-isolate transaction failed to commit." + failureGuard.DescribeErrors());
             }
             catch (Autodesk.Revit.Exceptions.InvalidOperationException ex)
             {

package/src/Revit/Tools/SetParameters.cs

@@ -19,7 +19,7 @@ namespace RevitBridge.Tools
 
         public string Name => "set_parameters";
         public string Label => "Set Parameters";
-        public string Description => "Write parameter values on elements — also the home for rename: parameter 'Name' covers levels, views, sheets, types, etc. (falls back to the element's Name property when the Name parameter is read-only). updates apply in ONE transaction: partial success commits and lists the failures; if every update fails the transaction is rolled back and nothing changes. parameter accepts a display name (Comments, Mark, Name), a BuiltInParameter enum name (e.g. ALL_MODEL_MARK), or guid:<GUID> for a shared parameter; type parameters live on the element type, so pass the type's id. Values are validated against the parameter's storage type; numeric values are interpreted in the document's display units for that parameter unless 'unit' (e.g. millimeters, feet, squareMeters) is given.";
+        public string Description => "Write parameter values on elements — also the home for rename: parameter 'Name' covers levels, views, sheets, types, etc. (falls back to the element's Name property when the Name parameter is read-only). updates apply in ONE transaction: partial success commits and lists the failures; if every update fails the transaction is rolled back and nothing changes. parameter accepts a display name (Comments, Mark, Name), a BuiltInParameter enum name (e.g. ALL_MODEL_MARK), or guid:<GUID> for a shared parameter; type parameters live on the element type, so pass the type's id. Values are validated against the parameter's storage type; numeric values are interpreted in the document's display units for that parameter unless 'unit' (e.g. millimeters, feet, squareMeters) is given. Revit warnings raised at commit (e.g. duplicate Mark values) are auto-dismissed and listed in commitWarnings — mention them to the user; error-severity failures roll the whole transaction back.";
         public bool Write => true;
 
         public object ParametersSchema => new
@@ -64,6 +64,7 @@ namespace RevitBridge.Tools
             var failed = new List<Dictionary<string, object?>>();
 
             using var transaction = new Transaction(doc, "set_parameters");
+            var failureGuard = FailureGuard.Attach(transaction);
             if (transaction.Start() != TransactionStatus.Started)
                 throw new InvalidOperationException("Unable to start the set_parameters transaction.");
 
@@ -95,7 +96,9 @@ namespace RevitBridge.Tools
                 if (succeeded.Count > 0)
                 {
                     if (transaction.Commit() != TransactionStatus.Committed)
-                        throw new InvalidOperationException("The set_parameters transaction failed to commit; no changes were saved.");
+                        throw new InvalidOperationException(
+                            "Revit rejected the set_parameters commit and the transaction was rolled back; no changes were saved."
+                            + failureGuard.DescribeErrors());
                 }
                 else
                 {
@@ -118,6 +121,8 @@ namespace RevitBridge.Tools
                 : succeeded.Count == 0
                     ? $"No updates applied; all {failed.Count} failed — transaction rolled back.{failureSample}"
                     : $"Updated {succeeded.Count} parameter value(s) on {elementCount} element(s); {failed.Count} failed.{failureSample}";
+            if (failureGuard.Warnings.Count > 0)
+                compact += $" {failureGuard.Warnings.Count} Revit warning(s) auto-dismissed at commit (see commitWarnings), e.g.: {failureGuard.Warnings[0]}";
 
             return new ToolOutput(new
             {
@@ -125,6 +130,7 @@ namespace RevitBridge.Tools
                 committed = succeeded.Count > 0,
                 succeeded,
                 failed,
+                commitWarnings = failureGuard.Warnings,
             }, compact);
         }