pi-revit 0.2.5 → 0.2.7

package/CHANGELOG.md

@@ -7,6 +7,33 @@ 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.7] - 2026-07-21
+
+### Added
+- Update announcements: after a pi-revit update, the next pi session shows a one-time
+  "What's new in pi-revit" note listing the changelog entries for every version since the
+  last one announced — the same mechanism pi uses for its own updates. The last-announced
+  version is remembered in `%APPDATA%\pi-revit\state.json` (kept outside the package
+  folder so npm updates can't erase it). Fresh installs stay silent.
+
+Extension-only change: no Revit add-in redeploy or Revit restart needed.
+
+## [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

package/extensions/pi-revit/index.ts

@@ -1,8 +1,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type, type TSchema } from "typebox";
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { version as packageVersion } from "../../package.json";
 
 interface BridgeInfo {
@@ -207,6 +208,73 @@ function versionMismatch(addinVersion: unknown): string | null {
 	return `pi-revit ${packageVersion} is installed, but the Revit add-in ${state} — the update is incomplete. Close Revit and run: npx.cmd -y pi-revit (or ask the agent to run scripts\\deploy.ps1 from the installed package, then restart Revit).`;
 }
 
+// ------------------------------------------------------------- what's new
+
+/** Stable per-user state file. Deliberately NOT under node_modules: npm wipes
+ * the package folder on every update, which is exactly when the last-announced
+ * version must survive. */
+function announcerStatePath(): string {
+	const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+	return path.join(appData, "pi-revit", "state.json");
+}
+
+function compareVersions(a: string, b: string): number {
+	const pa = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
+	const pb = b.split(".").map((part) => Number.parseInt(part, 10) || 0);
+	for (let i = 0; i < 3; i++) {
+		if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+	}
+	return 0;
+}
+
+/** Parses `## [x.y.z]` entries from the packaged CHANGELOG.md (the same header
+ * format pi's own changelog parser reads) and returns the ones newer than
+ * sinceVersion, newest first — so a 0.2.5 -> 0.2.9 jump shows all four. */
+async function newChangelogEntries(sinceVersion: string): Promise<{ version: string; body: string }[]> {
+	const changelogPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "CHANGELOG.md");
+	const markdown = await readFile(changelogPath, "utf8");
+	const headers = [...markdown.matchAll(/^##\s+\[?(\d+\.\d+\.\d+)\]?[^\n]*$/gm)];
+	const entries: { version: string; body: string }[] = [];
+	for (let i = 0; i < headers.length; i++) {
+		const version = headers[i][1];
+		if (compareVersions(version, sinceVersion) <= 0) continue;
+		const start = (headers[i].index ?? 0) + headers[i][0].length;
+		const end = i + 1 < headers.length ? headers[i + 1].index : markdown.length;
+		entries.push({ version, body: markdown.slice(start, end).trim() });
+	}
+	return entries;
+}
+
+/** Shows the changelog entries between the last announced version and the
+ * current one, once per update, then records the current version. A fresh
+ * install records silently (nothing is "new" yet). Every failure is swallowed:
+ * the announcer must never break a session. */
+async function announceUpdateOnce(notify: (message: string, level: "info") => void): Promise<void> {
+	try {
+		const statePath = announcerStatePath();
+		let lastVersion: string | null = null;
+		try {
+			const state = JSON.parse(await readFile(statePath, "utf8")) as { lastAnnouncedVersion?: string };
+			if (typeof state.lastAnnouncedVersion === "string") lastVersion = state.lastAnnouncedVersion;
+		} catch {
+			// First run: no state yet.
+		}
+		if (lastVersion === packageVersion) return;
+
+		if (lastVersion) {
+			const entries = await newChangelogEntries(lastVersion);
+			if (entries.length > 0) {
+				const text = entries.map((entry) => `pi-revit ${entry.version}\n${entry.body}`).join("\n\n");
+				notify(`What's new in pi-revit (updated from ${lastVersion}):\n\n${text}`, "info");
+			}
+		}
+		await mkdir(path.dirname(statePath), { recursive: true });
+		await writeFile(statePath, JSON.stringify({ lastAnnouncedVersion: packageVersion }, null, 2), "utf8");
+	} catch {
+		// Never let the announcer break a session.
+	}
+}
+
 function registerPing(pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "ping",
@@ -236,6 +304,7 @@ export default async function revitConnector(pi: ExtensionAPI) {
 	// where the user lands after running `pi update --extensions`. Bridge down at
 	// session start is the normal Revit-closed case: stay quiet.
 	pi.on("session_start", async (_event, ctx) => {
+		await announceUpdateOnce((message, level) => ctx.ui.notify(message, level));
 		try {
 			const payload = (await bridgeRequest("/ping", { method: "GET" }, undefined, 3_000)) as { addinVersion?: string };
 			const warning = versionMismatch(payload.addinVersion);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-revit",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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

@@ -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;
         }
 

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);
         }