pi-revit 0.1.0

package/src/Revit/Tools/ExportDocuments.cs

@@ -0,0 +1,256 @@
+using System.IO;
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    /// <summary>
+    /// Minimal document export: sheets/views to PDF, DWG, or PNG files, or the
+    /// model to IFC. Write = true for the filesystem side effects; only the IFC
+    /// branch wraps a Revit transaction (the IFC exporter stores IFC GUID
+    /// parameters on exported elements), owned here. Produced files are
+    /// discovered by diffing the output directory because Revit appends its own
+    /// view/sheet suffixes to multi-file export names.
+    /// </summary>
+    internal sealed class ExportDocuments : ITool
+    {
+        private const int MaxIds = 100;
+        private const int PngPixelWidth = 2048;
+
+        public string Name => "export_documents";
+        public string Label => "Export Documents";
+        public string Description => "Export documents from the open Revit model. format 'pdf'/'dwg'/'png' export the given sheet/view ids to files: pdf combines everything into one file by default (combine=false writes one PDF per sheet/view, named by Revit's naming rule); png renders 2048 px wide; ifc exports the whole model, or just what one given view shows. Files land in output_dir (created if missing; default: a fresh folder under the system temp directory); file_name_prefix sets the base file name (default: the document title; Revit appends view/sheet suffixes for multi-file exports). Returns the produced file paths with sizes. Find sheet/view ids with get_elements (category 'Sheets' or 'Views') first.";
+        public bool Write => true;
+        public string Tier => "advanced";
+
+        public object ParametersSchema => new
+        {
+            type = "object",
+            properties = new
+            {
+                format = new
+                {
+                    type = "string",
+                    @enum = new[] { "pdf", "dwg", "png", "ifc" },
+                    description = "Export format. pdf/dwg/png need sheet/view ids; ifc exports the model (optionally filtered to one view).",
+                },
+                ids = new
+                {
+                    type = "array",
+                    items = new { type = "integer" },
+                    description = "Sheet/view element ids to export (1-100). Required for pdf/dwg/png; for ifc at most one view id (default: the whole model).",
+                },
+                output_dir = new
+                {
+                    type = "string",
+                    description = "Output directory, created if missing. Default: a fresh folder under the system temp directory.",
+                },
+                file_name_prefix = new
+                {
+                    type = "string",
+                    description = "Base file name without extension. Default: the document title.",
+                },
+                combine = new
+                {
+                    type = "boolean",
+                    description = "pdf only: combine all sheets/views into one PDF. Default true.",
+                },
+            },
+            required = new[] { "format" },
+        };
+
+        public string? PromptSnippet => "Export sheets/views to PDF, DWG, or PNG files, or the model to IFC.";
+        public IReadOnlyList<string>? PromptGuidelines => new[]
+        {
+            "export_documents needs explicit sheet/view ids for pdf/dwg/png — find them with get_elements (category 'Sheets' or 'Views') first.",
+        };
+
+        public object? Execute(JsonElement args, ToolContext context)
+        {
+            var doc = context.Document ?? throw new NoActiveDocumentException();
+
+            string format = (JsonArgs.GetString(args, "format") ?? string.Empty).Trim().ToLowerInvariant();
+            if (format is not ("pdf" or "dwg" or "png" or "ifc"))
+                throw new ArgumentException($"Unknown format: {JsonArgs.GetString(args, "format")}. Supported: pdf, dwg, png, ifc.");
+
+            var views = ResolveViews(doc, args, format);
+            string outputDir = ResolveOutputDir(args);
+            string? prefixInput = JsonArgs.GetString(args, "file_name_prefix");
+            string baseName = SanitizeFileName(string.IsNullOrWhiteSpace(prefixInput) ? doc.Title : prefixInput.Trim());
+            bool combine = JsonArgs.GetBool(args, "combine", true);
+
+            // Produced files are found by diffing the directory; the timestamp check
+            // (with clock-skew slack) also catches overwrites of pre-existing names.
+            DateTime startedUtc = DateTime.UtcNow.AddSeconds(-2);
+            var before = new HashSet<string>(Directory.GetFiles(outputDir), StringComparer.OrdinalIgnoreCase);
+
+            switch (format)
+            {
+                case "pdf": ExportPdf(doc, views, outputDir, baseName, combine); break;
+                case "dwg": ExportDwg(doc, views, outputDir, baseName); break;
+                case "png": ExportPng(doc, views, outputDir, baseName); break;
+                default: ExportIfc(doc, views, outputDir, baseName); break;
+            }
+
+            var files = Directory.GetFiles(outputDir)
+                .Where(path => !before.Contains(path) || File.GetLastWriteTimeUtc(path) >= startedUtc)
+                .OrderBy(path => path, StringComparer.OrdinalIgnoreCase)
+                .Select(path => new Dictionary<string, object?>
+                {
+                    ["path"] = path,
+                    ["fileSizeBytes"] = new FileInfo(path).Length,
+                })
+                .ToList();
+            if (files.Count == 0)
+                throw new InvalidOperationException($"The {format} export finished but produced no files in {outputDir}.");
+
+            string sample = string.Join(", ", files.Take(3).Select(file => Path.GetFileName((string)file["path"]!)));
+            string compact = $"Exported {files.Count} {format.ToUpperInvariant()} file(s) to {outputDir}: {sample}{(files.Count > 3 ? $" (+{files.Count - 3} more)" : string.Empty)}.";
+            return new ToolOutput(new
+            {
+                format,
+                outputDir,
+                fileCount = files.Count,
+                files,
+            }, compact);
+        }
+
+        // ------------------------------------------------------------- format runs
+
+        private static void ExportPdf(Document doc, List<View> views, string outputDir, string baseName, bool combine)
+        {
+            var options = new PDFExportOptions
+            {
+                Combine = combine,
+                FileName = baseName, // names the combined file; per-view files follow Revit's naming rule
+            };
+            if (!Run(() => doc.Export(outputDir, views.Select(view => view.Id).ToList(), options), "PDF"))
+                throw new InvalidOperationException("Revit reported a failed PDF export.");
+        }
+
+        private static void ExportDwg(Document doc, List<View> views, string outputDir, string baseName)
+        {
+            bool available = true;
+            try
+            {
+                available = OptionalFunctionalityUtils.IsDWGExportAvailable();
+            }
+            catch
+            {
+                // Probe unavailable; let the export call itself report any failure.
+            }
+            if (!available)
+                throw new InvalidOperationException("DWG export is not available in this Revit installation.");
+
+            if (!Run(() => doc.Export(outputDir, baseName, views.Select(view => view.Id).ToList(), new DWGExportOptions()), "DWG"))
+                throw new InvalidOperationException("Revit reported a failed DWG export.");
+        }
+
+        private static void ExportPng(Document doc, List<View> views, string outputDir, string baseName)
+        {
+            var options = new ImageExportOptions
+            {
+                ExportRange = ExportRange.SetOfViews,
+                FilePath = Path.Combine(outputDir, baseName),
+                HLRandWFViewsFileType = ImageFileType.PNG,
+                ShadowViewsFileType = ImageFileType.PNG,
+                ImageResolution = ImageResolution.DPI_150,
+                ZoomType = ZoomFitType.FitToPage,
+                PixelSize = PngPixelWidth,
+                FitDirection = FitDirectionType.Horizontal,
+            };
+            options.SetViewsAndSheets(views.Select(view => view.Id).ToList());
+            Run(() => doc.ExportImage(options), "PNG");
+        }
+
+        /// <summary>The IFC exporter writes IFC GUID parameters onto exported elements,
+        /// so the Revit API requires a transaction around it — owned here, matching
+        /// Revit's own behavior of committing those GUIDs on export.</summary>
+        private static void ExportIfc(Document doc, List<View> views, string outputDir, string baseName)
+        {
+            var options = new IFCExportOptions();
+            if (views.Count == 1)
+                options.FilterViewId = views[0].Id;
+
+            using var transaction = new Transaction(doc, "export_documents: ifc");
+            if (transaction.Start() != TransactionStatus.Started)
+                throw new InvalidOperationException("Unable to start the IFC export transaction.");
+            try
+            {
+                if (!Run(() => doc.Export(outputDir, baseName, options), "IFC"))
+                    throw new InvalidOperationException("Revit reported a failed IFC export.");
+                if (transaction.Commit() != TransactionStatus.Committed)
+                    throw new InvalidOperationException("The IFC export transaction failed to commit.");
+            }
+            catch
+            {
+                if (transaction.GetStatus() == TransactionStatus.Started)
+                    transaction.RollBack();
+                throw;
+            }
+        }
+
+        /// <summary>Runs one export call, translating Revit API exceptions into plain errors.</summary>
+        private static T Run<T>(Func<T> export, string what)
+        {
+            try
+            {
+                return export();
+            }
+            catch (Autodesk.Revit.Exceptions.ApplicationException ex)
+            {
+                throw new InvalidOperationException($"Revit could not run the {what} export: {ex.Message}");
+            }
+        }
+
+        private static void Run(Action export, string what)
+            => Run<object?>(() => { export(); return null; }, what);
+
+        // ----------------------------------------------------------------- parsing
+
+        private static List<View> ResolveViews(Document doc, JsonElement args, string format)
+        {
+            bool present = args.ValueKind == JsonValueKind.Object
+                && args.TryGetProperty("ids", out var idsElement)
+                && idsElement.ValueKind != JsonValueKind.Null;
+            var ids = present ? JsonArgs.GetLongArray(args, "ids") : new List<long>();
+
+            if (ids.Count > MaxIds)
+                throw new ArgumentException($"Too many ids ({ids.Count}); max {MaxIds} per call. Export in batches.");
+            if (format != "ifc" && ids.Count == 0)
+                throw new ArgumentException($"format '{format}' requires ids of sheets or views. List them with get_elements (category 'Sheets' or 'Views').");
+            if (format == "ifc" && ids.Count > 1)
+                throw new ArgumentException("format 'ifc' takes at most one view id (the export is filtered to what that view shows); omit ids to export the whole model.");
+
+            var views = new List<View>(ids.Count);
+            foreach (long id in ids.Distinct())
+            {
+                var view = doc.GetElement(new ElementId(id)) as View
+                    ?? throw new ArgumentException($"id {id} is not a view or sheet.");
+                if (view.IsTemplate)
+                    throw new ArgumentException($"id {id} ('{view.Name}') is a view template and cannot be exported.");
+                if (format == "png" && view is ViewSchedule)
+                    throw new ArgumentException($"id {id} ('{view.Name}') is a schedule; schedules cannot be exported as PNG images.");
+                views.Add(view);
+            }
+            return views;
+        }
+
+        private static string ResolveOutputDir(JsonElement args)
+        {
+            string? requested = JsonArgs.GetString(args, "output_dir");
+            string outputDir = string.IsNullOrWhiteSpace(requested)
+                ? Path.Combine(Path.GetTempPath(), "revit_export_" + Guid.NewGuid().ToString("N"))
+                : Path.GetFullPath(requested.Trim());
+            Directory.CreateDirectory(outputDir);
+            return outputDir;
+        }
+
+        private static string SanitizeFileName(string name)
+        {
+            var invalid = Path.GetInvalidFileNameChars();
+            string clean = new string(name.Select(c => invalid.Contains(c) ? '_' : c).ToArray()).Trim();
+            return clean.Length > 0 ? clean : "export";
+        }
+    }
+}

package/src/Revit/Tools/GetElementDetails.cs

@@ -0,0 +1,318 @@
+using System.Globalization;
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    internal sealed class GetElementDetails : ITool
+    {
+        private const int MaxIds = 50;
+
+        public string Name => "get_element_details";
+        public string Label => "Get Element Details";
+        public string Description => "Inspect one or more elements by id: parameter VALUES (name, internal value, formatted displayValue, storage type, display unit where applicable, read-only/shared flags), plus optional type parameters, location (point/curve), bounding box, and materials. Internal numeric values are Revit internal units (feet-based); displayValue is formatted in the document's display units and 'unit' names that display unit. The single home for reading parameter values — get_elements only returns identity fields.";
+
+        public object ParametersSchema => new
+        {
+            type = "object",
+            properties = new
+            {
+                element_ids = new
+                {
+                    type = "array",
+                    items = new { type = "integer" },
+                    description = "Element ids to inspect (1-50 per call).",
+                },
+                parameter_names = new
+                {
+                    type = "array",
+                    items = new { type = "string" },
+                    description = "Only return these parameters (case-insensitive exact names). Default: all.",
+                },
+                include = new
+                {
+                    type = "object",
+                    description = "Optional sections per element.",
+                    properties = new
+                    {
+                        parameters = new { type = "boolean", description = "Instance parameter values. Default true." },
+                        type_parameters = new { type = "boolean", description = "Also include the element type's parameters, marked isType=true. Default false." },
+                        location = new { type = "boolean", description = "Location point or curve (coordinates in internal feet). Default false." },
+                        bounding_box = new { type = "boolean", description = "Model bounding box min/max (internal feet). Default false." },
+                        materials = new { type = "boolean", description = "Material ids/names with area/volume (internal units). Default false." },
+                    },
+                },
+            },
+            required = new[] { "element_ids" },
+        };
+
+        public string? PromptSnippet => "Read parameter values, location, bounding box, and materials for specific Revit elements.";
+        public IReadOnlyList<string>? PromptGuidelines => new[]
+        {
+            "Use get_element_details (with ids from get_elements or the user's selection) whenever parameter values are needed; numeric values carry both internal value and display value with its unit.",
+        };
+
+        public object? Execute(JsonElement args, ToolContext context)
+        {
+            var doc = context.Document ?? throw new NoActiveDocumentException();
+
+            var ids = JsonArgs.GetLongArray(args, "element_ids");
+            if (ids.Count == 0)
+                throw new ArgumentException("element_ids must contain at least one element id.");
+            if (ids.Count > MaxIds)
+                throw new ArgumentException($"Too many element_ids ({ids.Count}); max {MaxIds} per call. Inspect ids in batches.");
+
+            var parameterNames = JsonArgs.GetStringArray(args, "parameter_names");
+            HashSet<string>? nameFilter = parameterNames is { Count: > 0 }
+                ? new HashSet<string>(parameterNames, StringComparer.OrdinalIgnoreCase)
+                : null;
+
+            JsonElement include = args.TryGetProperty("include", out var includeElement) && includeElement.ValueKind == JsonValueKind.Object
+                ? includeElement
+                : default;
+            bool withParameters = JsonArgs.GetBool(include, "parameters", true);
+            bool withTypeParameters = JsonArgs.GetBool(include, "type_parameters", false);
+            bool withLocation = JsonArgs.GetBool(include, "location", false);
+            bool withBoundingBox = JsonArgs.GetBool(include, "bounding_box", false);
+            bool withMaterials = JsonArgs.GetBool(include, "materials", false);
+
+            var elements = new List<Dictionary<string, object?>>(ids.Count);
+            var notFound = new List<long>();
+            var compactParts = new List<string>();
+
+            foreach (long id in ids)
+            {
+                var element = doc.GetElement(new ElementId(id));
+                if (element is null)
+                {
+                    notFound.Add(id);
+                    continue;
+                }
+
+                var elementType = doc.GetElement(element.GetTypeId());
+                var dto = new Dictionary<string, object?>
+                {
+                    ["id"] = id,
+                    ["name"] = element.Name,
+                    ["category"] = element.Category?.Name,
+                    ["typeName"] = elementType?.Name,
+                    ["typeId"] = elementType?.Id.Value,
+                    ["levelId"] = element.LevelId is { } levelId && levelId != ElementId.InvalidElementId ? levelId.Value : (long?)null,
+                };
+
+                int parameterCount = 0;
+                if (withParameters)
+                {
+                    var parameters = new List<Dictionary<string, object?>>();
+                    AppendParameters(doc, element, nameFilter, isType: false, parameters);
+                    if (withTypeParameters && elementType != null)
+                        AppendParameters(doc, elementType, nameFilter, isType: true, parameters);
+                    dto["parameters"] = parameters;
+                    parameterCount = parameters.Count;
+                }
+
+                if (withLocation)
+                    dto["location"] = DescribeLocation(element);
+                if (withBoundingBox)
+                    dto["boundingBox"] = DescribeBoundingBox(element);
+                if (withMaterials)
+                    dto["materials"] = DescribeMaterials(doc, element);
+
+                elements.Add(dto);
+                compactParts.Add($"'{element.Name}' (id {id}, {element.Category?.Name ?? "no category"}{(withParameters ? $", {parameterCount} params" : string.Empty)})");
+            }
+
+            string compact = $"{elements.Count} element(s)"
+                + (compactParts.Count > 0 ? $": {string.Join("; ", compactParts.Take(5))}" : string.Empty)
+                + (compactParts.Count > 5 ? $" (+{compactParts.Count - 5} more)" : string.Empty)
+                + (notFound.Count > 0 ? $". Not found: {string.Join(", ", notFound)}" : string.Empty)
+                + ".";
+
+            return new ToolOutput(new { count = elements.Count, elements, not_found = notFound }, compact);
+        }
+
+        private static void AppendParameters(Document doc, Element element, HashSet<string>? nameFilter, bool isType, List<Dictionary<string, object?>> target)
+        {
+            var rows = new List<Dictionary<string, object?>>();
+            foreach (Parameter parameter in element.Parameters)
+            {
+                string name = parameter.Definition?.Name ?? string.Empty;
+                if (nameFilter != null && !nameFilter.Contains(name))
+                    continue;
+                rows.Add(DescribeParameter(doc, parameter, name, isType));
+            }
+            rows.Sort((a, b) => string.Compare(a["name"] as string, b["name"] as string, StringComparison.OrdinalIgnoreCase));
+            target.AddRange(rows);
+        }
+
+        private static Dictionary<string, object?> DescribeParameter(Document doc, Parameter parameter, string name, bool isType)
+        {
+            bool hasValue = parameter.HasValue;
+            var row = new Dictionary<string, object?>
+            {
+                ["name"] = name,
+                ["storageType"] = parameter.StorageType.ToString(),
+                ["isType"] = isType,
+                ["isReadOnly"] = parameter.IsReadOnly,
+            };
+
+            switch (parameter.StorageType)
+            {
+                case StorageType.String:
+                {
+                    string? text = hasValue ? parameter.AsString() : null;
+                    row["value"] = text;
+                    row["displayValue"] = text;
+                    break;
+                }
+                case StorageType.Integer:
+                    row["value"] = hasValue ? parameter.AsInteger() : (int?)null;
+                    row["displayValue"] = hasValue
+                        ? SafeValueString(parameter) ?? parameter.AsInteger().ToString(CultureInfo.InvariantCulture)
+                        : null;
+                    break;
+                case StorageType.Double:
+                {
+                    row["value"] = hasValue ? parameter.AsDouble() : (double?)null;
+                    row["displayValue"] = hasValue ? SafeValueString(parameter) : null;
+                    try
+                    {
+                        var spec = parameter.Definition?.GetDataType();
+                        if (spec != null && UnitUtils.IsMeasurableSpec(spec))
+                            row["unit"] = UnitResolver.ShortName(doc.GetUnits().GetFormatOptions(spec).GetUnitTypeId());
+                    }
+                    catch
+                    {
+                        // Leave unit out when the spec or format options are unavailable.
+                    }
+                    break;
+                }
+                case StorageType.ElementId:
+                {
+                    var referenced = hasValue ? parameter.AsElementId() : null;
+                    row["value"] = referenced != null && referenced != ElementId.InvalidElementId ? referenced.Value : (long?)null;
+                    row["displayValue"] = hasValue
+                        ? SafeValueString(parameter) ?? (referenced != null ? doc.GetElement(referenced)?.Name : null)
+                        : null;
+                    break;
+                }
+                default:
+                    row["value"] = null;
+                    row["displayValue"] = hasValue ? SafeValueString(parameter) : null;
+                    break;
+            }
+
+            if (parameter.IsShared)
+            {
+                row["isShared"] = true;
+                try
+                {
+                    row["guid"] = parameter.GUID.ToString();
+                }
+                catch
+                {
+                    // GUID can throw for malformed shared parameters; skip it.
+                }
+            }
+            if (parameter.Definition is InternalDefinition internalDefinition && internalDefinition.BuiltInParameter != BuiltInParameter.INVALID)
+                row["builtInParameter"] = internalDefinition.BuiltInParameter.ToString();
+
+            return row;
+        }
+
+        private static string? SafeValueString(Parameter parameter)
+        {
+            try
+            {
+                return parameter.AsValueString();
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static object? DescribeLocation(Element element)
+        {
+            switch (element.Location)
+            {
+                case LocationPoint point:
+                {
+                    var dto = new Dictionary<string, object?> { ["kind"] = "point", ["point"] = Point(point.Point) };
+                    try
+                    {
+                        dto["rotation"] = point.Rotation;
+                    }
+                    catch
+                    {
+                        // Not all point-located elements expose a rotation.
+                    }
+                    return dto;
+                }
+                case LocationCurve curve:
+                {
+                    var c = curve.Curve;
+                    var dto = new Dictionary<string, object?> { ["kind"] = "curve", ["isLine"] = c is Line };
+                    if (c.IsBound)
+                    {
+                        dto["start"] = Point(c.GetEndPoint(0));
+                        dto["end"] = Point(c.GetEndPoint(1));
+                        dto["length"] = c.Length;
+                    }
+                    return dto;
+                }
+                default:
+                    return null;
+            }
+        }
+
+        private static object? DescribeBoundingBox(Element element)
+        {
+            var box = element.get_BoundingBox(null);
+            return box is null ? null : new { min = Point(box.Min), max = Point(box.Max) };
+        }
+
+        private static List<Dictionary<string, object?>> DescribeMaterials(Document doc, Element element)
+        {
+            var result = new List<Dictionary<string, object?>>();
+            ICollection<ElementId> materialIds;
+            try
+            {
+                materialIds = element.GetMaterialIds(false);
+            }
+            catch
+            {
+                return result;
+            }
+
+            foreach (var materialId in materialIds)
+            {
+                var row = new Dictionary<string, object?>
+                {
+                    ["id"] = materialId.Value,
+                    ["name"] = doc.GetElement(materialId)?.Name,
+                };
+                try
+                {
+                    row["area"] = element.GetMaterialArea(materialId, false);
+                }
+                catch
+                {
+                    // Area is undefined for some element kinds.
+                }
+                try
+                {
+                    row["volume"] = element.GetMaterialVolume(materialId);
+                }
+                catch
+                {
+                    // Volume is undefined for some element kinds.
+                }
+                result.Add(row);
+            }
+            return result;
+        }
+
+        private static object Point(XYZ point) => new { x = point.X, y = point.Y, z = point.Z };
+    }
+}