pi-revit 0.1.0

package/src/Revit/Tools/GetModelHealth.cs

@@ -0,0 +1,191 @@
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    /// <summary>
+    /// Model audit. Document.GetWarnings() returns FailureMessage API objects that
+    /// do not survive plain JSON serialization, so they are flattened here into
+    /// clean DTOs grouped by description, plus basic structure counts: worksharing
+    /// status and user worksets, phases, design options, in-place families, and
+    /// the total element count.
+    /// </summary>
+    internal sealed class GetModelHealth : ITool
+    {
+        private const int MaxGroups = 100;
+        private const int MaxElementsPerGroup = 20;
+
+        public string Name => "get_model_health";
+        public string Label => "Get Model Health";
+        public string Description => "Audit the open Revit model: every document warning grouped by description (description, severity, occurrence count, failing element ids+names — the top 100 groups ordered by count, up to 20 elements each), plus structure counts: worksharing status with user worksets, phases, design options, in-place families, and the total element count. Read-only; use it to review model quality, e.g. before and after bulk edits.";
+        public string Tier => "advanced";
+
+        public object ParametersSchema => new { type = "object", properties = new { }, required = Array.Empty<string>() };
+
+        public string? PromptSnippet => "Audit the model: warnings grouped by description plus workset/phase/design-option counts.";
+        public IReadOnlyList<string>? PromptGuidelines => new[]
+        {
+            "Run get_model_health to review Revit warnings (grouped, with failing element ids) before and after bulk modifications.",
+        };
+
+        public object? Execute(JsonElement args, ToolContext context)
+        {
+            var doc = context.Document ?? throw new NoActiveDocumentException();
+
+            var warnings = doc.GetWarnings();
+            var groups = warnings
+                .GroupBy(SafeDescription, StringComparer.Ordinal)
+                .Select(group =>
+                {
+                    var elementIds = group
+                        .SelectMany(SafeFailingElements)
+                        .Distinct()
+                        .ToList();
+                    return new Dictionary<string, object?>
+                    {
+                        ["description"] = group.Key,
+                        ["severity"] = SafeSeverity(group.First()),
+                        ["count"] = group.Count(),
+                        ["elementCount"] = elementIds.Count,
+                        ["elements"] = elementIds
+                            .Take(MaxElementsPerGroup)
+                            .Select(id => new Dictionary<string, object?>
+                            {
+                                ["id"] = id.Value,
+                                ["name"] = SafeName(doc, id),
+                            })
+                            .ToList(),
+                        ["elementsTruncated"] = elementIds.Count > MaxElementsPerGroup,
+                    };
+                })
+                .OrderByDescending(group => (int)group["count"]!)
+                .ToList();
+            bool groupsTruncated = groups.Count > MaxGroups;
+            var topGroups = groups.Take(MaxGroups).ToList();
+
+            bool workshared = doc.IsWorkshared;
+            List<string>? worksetNames = null;
+            if (workshared)
+            {
+                worksetNames = new FilteredWorksetCollector(doc)
+                    .OfKind(WorksetKind.UserWorkset)
+                    .ToWorksets()
+                    .Select(workset => workset.Name)
+                    .OrderBy(name => name, StringComparer.OrdinalIgnoreCase)
+                    .ToList();
+            }
+
+            var phaseNames = new List<string>();
+            foreach (Phase phase in doc.Phases)
+                phaseNames.Add(phase.Name);
+
+            var designOptionNames = new FilteredElementCollector(doc)
+                .OfClass(typeof(DesignOption))
+                .Select(option => option.Name)
+                .OrderBy(name => name, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            int inPlaceFamilies = new FilteredElementCollector(doc)
+                .OfClass(typeof(Family))
+                .Cast<Family>()
+                .Count(family => family.IsInPlace);
+
+            int totalElements = new FilteredElementCollector(doc)
+                .WhereElementIsNotElementType()
+                .GetElementCount();
+
+            var payload = new Dictionary<string, object?>
+            {
+                ["warnings"] = new Dictionary<string, object?>
+                {
+                    ["total"] = warnings.Count,
+                    ["groupCount"] = groups.Count,
+                    ["groups"] = topGroups,
+                    ["groupsTruncated"] = groupsTruncated,
+                },
+                ["workshared"] = workshared,
+                ["worksets"] = worksetNames is null ? null : new Dictionary<string, object?>
+                {
+                    ["count"] = worksetNames.Count,
+                    ["names"] = worksetNames,
+                },
+                ["phases"] = new Dictionary<string, object?>
+                {
+                    ["count"] = phaseNames.Count,
+                    ["names"] = phaseNames,
+                },
+                ["designOptions"] = new Dictionary<string, object?>
+                {
+                    ["count"] = designOptionNames.Count,
+                    ["names"] = designOptionNames,
+                },
+                ["inPlaceFamilies"] = inPlaceFamilies,
+                ["totalElements"] = totalElements,
+            };
+
+            string topWarning = topGroups.Count > 0
+                ? $" Top: '{Shorten((string)topGroups[0]["description"]!, 80)}' x{topGroups[0]["count"]}."
+                : string.Empty;
+            string compact = $"{warnings.Count} warning(s) in {groups.Count} group(s); "
+                + (workshared ? $"workshared ({worksetNames!.Count} workset(s)); " : "not workshared; ")
+                + $"{phaseNames.Count} phase(s); {designOptionNames.Count} design option(s); {inPlaceFamilies} in-place families; {totalElements} elements."
+                + topWarning;
+
+            return new ToolOutput(payload, compact);
+        }
+
+        // ------------------------------------------------- FailureMessage flattening
+
+        private static string SafeDescription(FailureMessage warning)
+        {
+            try
+            {
+                string text = warning.GetDescriptionText();
+                return string.IsNullOrWhiteSpace(text) ? "(no description)" : text.Trim();
+            }
+            catch
+            {
+                return "(no description)";
+            }
+        }
+
+        private static string? SafeSeverity(FailureMessage warning)
+        {
+            try
+            {
+                return warning.GetSeverity().ToString();
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static IEnumerable<ElementId> SafeFailingElements(FailureMessage warning)
+        {
+            try
+            {
+                return warning.GetFailingElements();
+            }
+            catch
+            {
+                return Enumerable.Empty<ElementId>();
+            }
+        }
+
+        private static string? SafeName(Document doc, ElementId id)
+        {
+            try
+            {
+                return doc.GetElement(id)?.Name;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static string Shorten(string text, int max)
+            => text.Length <= max ? text : text[..(max - 3)] + "...";
+    }
+}

package/src/Revit/Tools/GetModelOverview.cs

@@ -0,0 +1,159 @@
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    internal sealed class GetModelOverview : ITool
+    {
+        public string Name => "get_model_overview";
+        public string Label => "Get Model Overview";
+        public string Description => "One-call orientation for the open Revit model: project metadata (title, name, number, client, address, file path, Revit version, display units), levels with elevations, grids, element counts for the major categories, and totals (elements, views, sheets). Use this first when starting work on a model.";
+        public object ParametersSchema => new { type = "object", properties = new { }, required = Array.Empty<string>() };
+        public string? PromptSnippet => "Get project info, units, levels, grids, and category counts for the open Revit model.";
+        public IReadOnlyList<string>? PromptGuidelines => new[]
+        {
+            "Call get_model_overview first when starting work on a Revit model; it covers project info, units, levels, grids, and per-category counts in one call.",
+        };
+
+        private static readonly IReadOnlyDictionary<string, BuiltInCategory> MajorCategories = new Dictionary<string, BuiltInCategory>
+        {
+            ["Walls"] = BuiltInCategory.OST_Walls,
+            ["Doors"] = BuiltInCategory.OST_Doors,
+            ["Windows"] = BuiltInCategory.OST_Windows,
+            ["Floors"] = BuiltInCategory.OST_Floors,
+            ["Rooms"] = BuiltInCategory.OST_Rooms,
+            ["Areas"] = BuiltInCategory.OST_Areas,
+            ["Ceilings"] = BuiltInCategory.OST_Ceilings,
+            ["Roofs"] = BuiltInCategory.OST_Roofs,
+            ["Columns"] = BuiltInCategory.OST_Columns,
+            ["Structural Columns"] = BuiltInCategory.OST_StructuralColumns,
+            ["Structural Framing"] = BuiltInCategory.OST_StructuralFraming,
+            ["Stairs"] = BuiltInCategory.OST_Stairs,
+            ["Furniture"] = BuiltInCategory.OST_Furniture,
+            ["Generic Models"] = BuiltInCategory.OST_GenericModel,
+            ["Pipes"] = BuiltInCategory.OST_PipeCurves,
+            ["Ducts"] = BuiltInCategory.OST_DuctCurves,
+        };
+
+        public object? Execute(JsonElement args, ToolContext context)
+        {
+            var doc = context.Document ?? throw new NoActiveDocumentException();
+            var info = doc.ProjectInformation;
+            var units = doc.GetUnits();
+
+            string system = doc.DisplayUnitSystem == DisplayUnit.IMPERIAL ? "imperial" : "metric";
+            string? lengthUnit = DisplayUnitName(units, SpecTypeId.Length);
+            var project = new Dictionary<string, object?>
+            {
+                ["title"] = doc.Title,
+                ["name"] = info?.Name,
+                ["number"] = info?.Number,
+                ["clientName"] = info?.ClientName,
+                ["address"] = info?.Address,
+                ["buildingName"] = info?.BuildingName,
+                ["author"] = info?.Author,
+                ["filePath"] = doc.PathName,
+                ["revitVersion"] = doc.Application.VersionNumber,
+                ["units"] = new Dictionary<string, object?>
+                {
+                    ["system"] = system,
+                    ["length"] = lengthUnit,
+                    ["area"] = DisplayUnitName(units, SpecTypeId.Area),
+                    ["volume"] = DisplayUnitName(units, SpecTypeId.Volume),
+                },
+            };
+
+            var levels = new FilteredElementCollector(doc)
+                .OfClass(typeof(Level))
+                .Cast<Level>()
+                .OrderBy(level => level.Elevation)
+                .Select(level => new Dictionary<string, object?>
+                {
+                    ["id"] = level.Id.Value,
+                    ["name"] = level.Name,
+                    ["elevation_ft"] = level.Elevation,
+                    ["elevation_display"] = FormatLength(units, level.Elevation),
+                })
+                .ToList();
+
+            var grids = new FilteredElementCollector(doc)
+                .OfClass(typeof(Grid))
+                .Cast<Grid>()
+                .OrderBy(grid => grid.Name, StringComparer.OrdinalIgnoreCase)
+                .Select(grid => new Dictionary<string, object?>
+                {
+                    ["id"] = grid.Id.Value,
+                    ["name"] = grid.Name,
+                })
+                .ToList();
+
+            var counts = new Dictionary<string, int>();
+            foreach (var (label, category) in MajorCategories)
+            {
+                try
+                {
+                    counts[label] = new FilteredElementCollector(doc)
+                        .OfCategory(category)
+                        .WhereElementIsNotElementType()
+                        .GetElementCount();
+                }
+                catch
+                {
+                    counts[label] = 0;
+                }
+            }
+
+            int totalElements = new FilteredElementCollector(doc).WhereElementIsNotElementType().GetElementCount();
+            int sheets = new FilteredElementCollector(doc).OfClass(typeof(ViewSheet)).GetElementCount();
+            int views = new FilteredElementCollector(doc)
+                .OfClass(typeof(View))
+                .Cast<View>()
+                .Count(view => !view.IsTemplate && view is not ViewSheet);
+
+            var totals = new Dictionary<string, int>
+            {
+                ["elements"] = totalElements,
+                ["views"] = views,
+                ["sheets"] = sheets,
+                ["levels"] = levels.Count,
+                ["grids"] = grids.Count,
+            };
+
+            var topCategories = counts
+                .Where(pair => pair.Value > 0)
+                .OrderByDescending(pair => pair.Value)
+                .Take(5)
+                .Select(pair => $"{pair.Key} {pair.Value}")
+                .ToList();
+            string numberPart = string.IsNullOrWhiteSpace(info?.Number) ? string.Empty : $" (project {info!.Number})";
+            string compact = $"'{doc.Title}'{numberPart}: {totalElements} elements, {levels.Count} levels, {grids.Count} grids, {sheets} sheets, {views} views; units {system} ({lengthUnit})."
+                + (topCategories.Count > 0 ? $" Top categories: {string.Join(", ", topCategories)}." : string.Empty);
+
+            return new ToolOutput(new { project, levels, grids, counts, totals }, compact);
+        }
+
+        private static string? DisplayUnitName(Units units, ForgeTypeId spec)
+        {
+            try
+            {
+                return UnitResolver.ShortName(units.GetFormatOptions(spec).GetUnitTypeId());
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static string? FormatLength(Units units, double value)
+        {
+            try
+            {
+                return UnitFormatUtils.Format(units, SpecTypeId.Length, value, false);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+    }
+}

package/src/Revit/Tools/ManageSelection.cs

@@ -0,0 +1,220 @@
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    /// <summary>
+    /// Selection and view-focus management. Selection changes and zoom are pure UI
+    /// state. Temporary isolate is view state (not model data), but the Revit API
+    /// only toggles it inside an open transaction, so exactly that branch wraps a
+    /// small internal one; the tool itself stays a read tool (Write = false).
+    /// </summary>
+    internal sealed class ManageSelection : ITool
+    {
+        public string Name => "manage_selection";
+        public string Label => "Manage Selection";
+        public string Description => "Manage the Revit selection and view focus. action 'get' returns the currently selected elements (id, name, category, typeName, levelId); 'set'/'add'/'remove' change the selection with element_ids; 'clear' empties it; 'zoom' zooms open views to element_ids (default: the current selection). isolate_in_view=true additionally applies Revit's Temporary Hide/Isolate to the affected elements in the active view — temporary view state, not a model change (Revit needs a brief internal transaction to toggle it); with an empty target set (action 'clear', or 'get' with nothing selected) it resets the temporary isolate instead. Selection and zoom never modify model data.";
+
+        public object ParametersSchema => new
+        {
+            type = "object",
+            properties = new
+            {
+                action = new
+                {
+                    type = "string",
+                    @enum = new[] { "get", "set", "add", "remove", "clear", "zoom" },
+                    description = "What to do with the selection. Default get.",
+                },
+                element_ids = new
+                {
+                    type = "array",
+                    items = new { type = "integer" },
+                    description = "Element ids for set/add/remove/zoom. zoom falls back to the current selection when omitted.",
+                },
+                isolate_in_view = new
+                {
+                    type = "boolean",
+                    description = "Temporarily isolate the affected elements in the active view (temporary view state only; resets the temporary isolate when the target set is empty). Default false.",
+                },
+            },
+            required = Array.Empty<string>(),
+        };
+
+        public string? PromptSnippet => "Read or change the Revit selection; zoom to or temporarily isolate elements.";
+        public IReadOnlyList<string>? PromptGuidelines => new[]
+        {
+            "Use manage_selection (action 'get') when the user refers to elements they selected in Revit ('what is selected', 'these elements').",
+            "To show results in Revit, pass ids from get_elements to manage_selection action 'set' or 'zoom', adding isolate_in_view to focus a crowded view.",
+        };
+
+        public object? Execute(JsonElement args, ToolContext context)
+        {
+            var uiDocument = context.UIApplication?.ActiveUIDocument ?? throw new NoActiveDocumentException();
+            var doc = uiDocument.Document;
+
+            string action = (JsonArgs.GetString(args, "action") ?? "get").Trim().ToLowerInvariant();
+            bool isolateInView = JsonArgs.GetBool(args, "isolate_in_view", false);
+            var (requestedCount, validIds, notFound) = ResolveElementIds(doc, args);
+
+            if (action is "set" or "add" or "remove" && requestedCount == 0)
+                throw new ArgumentException($"action '{action}' needs element_ids. Use action 'clear' to empty the selection.");
+            if (requestedCount > 0 && validIds.Count == 0)
+                throw new ArgumentException($"None of the element_ids exist in the document: {string.Join(", ", notFound)}.");
+
+            var payload = new Dictionary<string, object?> { ["action"] = action };
+            var compactParts = new List<string>();
+            List<ElementId> isolateTargets;
+
+            switch (action)
+            {
+                case "get":
+                {
+                    var selectedIds = uiDocument.Selection.GetElementIds().ToList();
+                    var rows = selectedIds
+                        .Select(id => doc.GetElement(id))
+                        .Where(element => element != null)
+                        .Select(element => ElementIdentity.Build(doc, element!, ElementIdentity.Fields))
+                        .ToList();
+                    payload["count"] = rows.Count;
+                    payload["elements"] = rows;
+                    string sample = rows.Count > 0
+                        ? $": {string.Join(", ", rows.Take(5).Select(row => $"'{row["name"]}' ({row["id"]})"))}{(rows.Count > 5 ? $" (+{rows.Count - 5} more)" : string.Empty)}"
+                        : string.Empty;
+                    compactParts.Add($"{rows.Count} element(s) selected{sample}");
+                    isolateTargets = selectedIds;
+                    break;
+                }
+                case "set":
+                case "add":
+                case "remove":
+                {
+                    var current = uiDocument.Selection.GetElementIds();
+                    List<ElementId> next = action switch
+                    {
+                        "set" => validIds,
+                        "add" => current.Union(validIds).ToList(),
+                        _ => current.Except(validIds).ToList(),
+                    };
+                    uiDocument.Selection.SetElementIds(next);
+                    payload["selectedCount"] = next.Count;
+                    compactParts.Add(action switch
+                    {
+                        "set" => $"Selection set to {next.Count} element(s)",
+                        "add" => $"Added {next.Count - current.Count} element(s); {next.Count} now selected",
+                        _ => $"Removed {current.Count - next.Count} element(s); {next.Count} still selected",
+                    });
+                    isolateTargets = next;
+                    break;
+                }
+                case "clear":
+                {
+                    uiDocument.Selection.SetElementIds(new List<ElementId>());
+                    payload["selectedCount"] = 0;
+                    compactParts.Add("Selection cleared");
+                    isolateTargets = new List<ElementId>();
+                    break;
+                }
+                case "zoom":
+                {
+                    var targets = validIds.Count > 0 ? validIds : uiDocument.Selection.GetElementIds().ToList();
+                    if (targets.Count == 0)
+                        throw new ArgumentException("action 'zoom' needs element_ids, or a non-empty current selection to zoom to.");
+                    uiDocument.ShowElements(targets);
+                    payload["shownCount"] = targets.Count;
+                    compactParts.Add($"Zoomed open views to {targets.Count} element(s)");
+                    isolateTargets = targets;
+                    break;
+                }
+                default:
+                    throw new ArgumentException($"Unknown action: {action}. Supported: get, set, add, remove, clear, zoom.");
+            }
+
+            if (notFound.Count > 0)
+            {
+                payload["not_found"] = notFound;
+                compactParts.Add($"ids not found: {string.Join(", ", notFound)}");
+            }
+
+            if (isolateInView)
+            {
+                var view = uiDocument.ActiveGraphicalView
+                    ?? throw new ArgumentException("isolate_in_view requires an active graphical view in Revit.");
+                ApplyTemporaryIsolate(doc, view, isolateTargets);
+                payload["viewId"] = view.Id.Value;
+                payload["viewName"] = view.Name;
+                if (isolateTargets.Count == 0)
+                {
+                    payload["temporaryIsolateReset"] = true;
+                    compactParts.Add($"temporary isolate reset in view '{view.Name}'");
+                }
+                else
+                {
+                    payload["isolatedCount"] = isolateTargets.Count;
+                    compactParts.Add($"{isolateTargets.Count} element(s) temporarily isolated in view '{view.Name}'");
+                }
+            }
+            else
+            {
+                payload["activeViewId"] = doc.ActiveView?.Id.Value;
+            }
+
+            return new ToolOutput(payload, string.Join("; ", compactParts) + ".");
+        }
+
+        private static (int RequestedCount, List<ElementId> Valid, List<long> NotFound) ResolveElementIds(Document doc, JsonElement args)
+        {
+            bool present = args.ValueKind == JsonValueKind.Object
+                && args.TryGetProperty("element_ids", out var idsElement)
+                && idsElement.ValueKind != JsonValueKind.Null;
+            if (!present)
+                return (0, new List<ElementId>(), new List<long>());
+
+            var requested = JsonArgs.GetLongArray(args, "element_ids");
+            var valid = new List<ElementId>(requested.Count);
+            var notFound = new List<long>();
+            foreach (long id in requested.Distinct())
+            {
+                var elementId = new ElementId(id);
+                if (doc.GetElement(elementId) != null)
+                    valid.Add(elementId);
+                else
+                    notFound.Add(id);
+            }
+            return (requested.Count, valid, notFound);
+        }
+
+        /// <summary>
+        /// Temporary hide/isolate is view state, not model data, but the Revit API
+        /// only changes it inside an open transaction — so exactly this branch wraps
+        /// a small one while the tool stays Write = false.
+        /// </summary>
+        private static void ApplyTemporaryIsolate(Document doc, View view, ICollection<ElementId> elementIds)
+        {
+            using var transaction = new Transaction(doc, "manage_selection: temporary isolate");
+            if (transaction.Start() != TransactionStatus.Started)
+                throw new InvalidOperationException("Unable to start the temporary-isolate transaction.");
+            try
+            {
+                if (elementIds.Count == 0)
+                    view.DisableTemporaryViewMode(TemporaryViewMode.TemporaryHideIsolate);
+                else
+                    view.IsolateElementsTemporary(elementIds);
+                if (transaction.Commit() != TransactionStatus.Committed)
+                    throw new InvalidOperationException("The temporary-isolate transaction failed to commit.");
+            }
+            catch (Autodesk.Revit.Exceptions.InvalidOperationException ex)
+            {
+                if (transaction.GetStatus() == TransactionStatus.Started)
+                    transaction.RollBack();
+                throw new ArgumentException($"The active view '{view.Name}' does not support temporary isolate: {ex.Message}");
+            }
+            catch
+            {
+                if (transaction.GetStatus() == TransactionStatus.Started)
+                    transaction.RollBack();
+                throw;
+            }
+        }
+    }
+}