pi-revit 0.1.0

package/src/Revit/Tools/GetElementTypes.cs

@@ -0,0 +1,151 @@
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    internal sealed class GetElementTypes : ITool
+    {
+        private const int DefaultLimit = 200;
+        private const int MaxLimit = 1000;
+
+        public string Name => "get_element_types";
+        public string Label => "Get Element Types";
+        public string Description => "List element types / family symbols (wall types, door types, ...) for a category or class: id, name, familyName, category, isFamilySymbol, optional placed-instance count per type (answers 'used vs merely loaded'). Use the ids with get_elements type_id or for type assignment.";
+
+        public object ParametersSchema => new
+        {
+            type = "object",
+            properties = new
+            {
+                category = new
+                {
+                    type = "string",
+                    description = "Category: BuiltInCategory enum name (e.g. OST_Walls) or display name (e.g. Walls, Doors).",
+                },
+                of_class = new
+                {
+                    type = "string",
+                    description = "Element type class, e.g. WallType, FloorType, FamilySymbol.",
+                },
+                name_filter = new
+                {
+                    type = "string",
+                    description = "Case-insensitive substring matched against type name and family name.",
+                },
+                include_instance_count = new
+                {
+                    type = "boolean",
+                    description = "Add the number of placed instances per type. Counts the scoped category (or the whole model without a category), so it costs one extra pass. Default false.",
+                },
+                offset = new { type = "integer", description = "Pagination offset. Default 0." },
+                limit = new { type = "integer", description = "Max types to return (1-1000). Default 200." },
+            },
+            required = Array.Empty<string>(),
+        };
+
+        public string? PromptSnippet => "List Revit element types / family symbols with optional placed-instance counts.";
+        public IReadOnlyList<string>? PromptGuidelines => new[]
+        {
+            "Use get_element_types to discover the available types of a category; set include_instance_count to see which types are actually placed.",
+        };
+
+        public object? Execute(JsonElement args, ToolContext context)
+        {
+            var doc = context.Document ?? throw new NoActiveDocumentException();
+
+            string? categoryInput = JsonArgs.GetString(args, "category");
+            string? classInput = JsonArgs.GetString(args, "of_class");
+            string needle = JsonArgs.GetString(args, "name_filter")?.Trim() ?? string.Empty;
+            bool includeInstanceCount = JsonArgs.GetBool(args, "include_instance_count", false);
+            int offset = Math.Max(0, JsonArgs.GetInt(args, "offset", 0));
+            int limit = Math.Clamp(JsonArgs.GetInt(args, "limit", DefaultLimit), 1, MaxLimit);
+
+            ElementId? categoryId = string.IsNullOrWhiteSpace(categoryInput) ? null : CategoryResolver.Resolve(doc, categoryInput);
+            Type? elementClass = string.IsNullOrWhiteSpace(classInput) ? null : ElementClassResolver.Resolve(classInput);
+
+            var collector = new FilteredElementCollector(doc);
+            if (categoryId != null)
+                collector = collector.OfCategoryId(categoryId);
+            if (elementClass != null)
+                collector = collector.OfClass(elementClass);
+            collector = collector.WhereElementIsElementType();
+
+            var types = collector
+                .OfType<ElementType>()
+                .Select(type => new { Type = type, Name = type.Name ?? string.Empty, FamilyName = SafeFamilyName(type) })
+                .Where(entry => needle.Length == 0
+                    || entry.Name.Contains(needle, StringComparison.OrdinalIgnoreCase)
+                    || entry.FamilyName.Contains(needle, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(entry => entry.FamilyName, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(entry => entry.Name, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            Dictionary<long, int>? instanceCounts = null;
+            if (includeInstanceCount)
+            {
+                instanceCounts = new Dictionary<long, int>();
+                var instances = new FilteredElementCollector(doc);
+                if (categoryId != null)
+                    instances = instances.OfCategoryId(categoryId);
+                foreach (Element element in instances.WhereElementIsNotElementType())
+                {
+                    long typeIdValue = element.GetTypeId().Value;
+                    if (typeIdValue < 0)
+                        continue;
+                    instanceCounts[typeIdValue] = instanceCounts.TryGetValue(typeIdValue, out int count) ? count + 1 : 1;
+                }
+            }
+
+            int total = types.Count;
+            var window = types.Skip(offset).Take(limit).Select(entry =>
+            {
+                var row = new Dictionary<string, object?>
+                {
+                    ["id"] = entry.Type.Id.Value,
+                    ["name"] = entry.Name,
+                    ["familyName"] = entry.FamilyName,
+                    ["category"] = entry.Type.Category?.Name,
+                    ["isFamilySymbol"] = entry.Type is FamilySymbol,
+                };
+                if (instanceCounts != null)
+                    row["instanceCount"] = instanceCounts.TryGetValue(entry.Type.Id.Value, out int count) ? count : 0;
+                return row;
+            }).ToList();
+
+            bool hasMore = offset + window.Count < total;
+            int? nextOffset = hasMore ? offset + window.Count : null;
+
+            string scope = !string.IsNullOrWhiteSpace(categoryInput) ? categoryInput.Trim()
+                : !string.IsNullOrWhiteSpace(classInput) ? classInput.Trim()
+                : "all categories";
+            string sampleText = window.Count > 0
+                ? $" Sample: {string.Join(", ", window.Take(3).Select(row => $"'{row["familyName"]}: {row["name"]}' ({row["id"]})"))}."
+                : string.Empty;
+            string compact = hasMore
+                ? $"element types ({scope}): {total} total, returned {window.Count} at offset {offset}, has_more (next_offset {nextOffset}).{sampleText}"
+                : $"element types ({scope}): {total} total, returned {window.Count} at offset {offset}.{sampleText}";
+
+            return new ToolOutput(new
+            {
+                total_count = total,
+                returned_count = window.Count,
+                offset,
+                has_more = hasMore,
+                next_offset = nextOffset,
+                types = window,
+            }, compact);
+        }
+
+        private static string SafeFamilyName(ElementType type)
+        {
+            try
+            {
+                return type.FamilyName ?? string.Empty;
+            }
+            catch
+            {
+                return string.Empty;
+            }
+        }
+    }
+}