A tool that dumps any .NET Enums to readable TypeScript

EnumDumper.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace EnumDumper
{
    static class Program
    {
        static void Main(string[] args)
        {
            var assembly = typeof(Microsoft.WindowsLive.FallbackLogic).Assembly;
            var types = assembly.GetTypes().Where(t => t.IsEnum).OrderBy(t => t.FullName).ToArray();
            var stack = new Stack<string>();
            var str = new StringBuilder();
            foreach (var type in types)
            {
                var nameBits = type.FullName.Split('.', StringSplitOptions.RemoveEmptyEntries);
                nameBits = nameBits.Take(nameBits.Length - 1).ToArray();
                while (stack.Count > nameBits.Length)
                {
                    stack.Pop();
                    WritePop(stack, str);
                }

                var i = Math.Min(nameBits.Length - 1, stack.Count - 1);
                for (; i >= 0; i--)
                {
                    var bit = nameBits[i];
                    if (stack.TryPeek(out var currentBit) && currentBit != bit)
                    {
                        stack.Pop();
                        WritePop(stack, str);
                    }
                    else
                    {
                        break;
                    }
                }

                i = stack.Count;

                for (; i < nameBits.Length; i++)
                {
                    str.AppendWhitespace(stack.Count);
                    str.AppendLine($"export namespace {nameBits[i]} {{ ");
                    stack.Push(nameBits[i]);
                }

                str.AppendWhitespace(stack.Count);
                str.AppendLine($"export enum {type.Name} {{");

                var num = 0;
                var fields = type.GetFields().Skip(1).ToArray();
                foreach (var field in fields)
                {
                    var writeNum = false;
                    var value = Convert.ToInt32(field.GetValue(null));
                    var name = field.Name;
                    if (char.IsUpper(name[0]))
                    {
                        var toLower = new String(name.TakeWhile(c => char.IsUpper(c) && c != '_').ToArray()).ToLower();
                        name = name.Remove(0, toLower.Length);
                        name = toLower + name;
                    }

                    if (num != value)
                    {
                        num = value;
                        writeNum = true;
                    }

                    str.AppendWhitespace(stack.Count + 1);
                    str.Append(name);

                    if (writeNum)
                    {
                        str.Append(" = ");
                        str.Append(num);
                    }

                    str.AppendLine(",");

                    num++;
                }

                str.AppendWhitespace(stack.Count);
                str.AppendLine("}");
            }

            while (stack.TryPop(out _))
            {
                WritePop(stack, str);
            }

            File.WriteAllText("test.ts", str.ToString());
        }

        private static void AppendWhitespace(this StringBuilder str, int depth)
        {
            for (int j = 0; j < depth * 4; j++)
                str.Append(' ');
        }

        private static void WritePop(Stack<string> stack, StringBuilder str)
        {
            str.AppendWhitespace(stack.Count);
            str.AppendLine("}");
        }
    }
}