Fix formatting in usage section of README

Updated usage instructions for GIT Version Control.

Editor/GitPanel.cs

@@ -64,6 +64,7 @@ public class GitPanel : EditorWindow
         
         if (hasRepo) 
         {
+            ExportPackageInventory();
             currentBranchName = RunGitCommand("rev-parse --abbrev-ref HEAD").Trim();
             FetchBranches();
         }
@@ -148,6 +149,13 @@ public class GitPanel : EditorWindow
             {
                 EditorPrefs.SetString(prefsKey, webUrlOverride.Trim());
             }
+
+            GUILayout.Space(10);
+            GUILayout.Label("Inventory Management", EditorStyles.miniBoldLabel);
+            if (GUILayout.Button("📄 Sync Package Inventory (Unity & VRChat)", GUILayout.Height(25)))
+            {
+                ExportPackageInventory();
+            }
             EditorGUILayout.EndVertical();
             GUILayout.Space(5);
         }
@@ -248,6 +256,7 @@ public class GitPanel : EditorWindow
                 UnityEngine.Debug.Log("Git-Tool: Changes successfully pushed!");
                 commitMessage = ""; 
             }
+            LiveSyncPanel.BroadcastGitUpdate();
             RefreshData();
         }
 
@@ -409,6 +418,124 @@ public class GitPanel : EditorWindow
         if (!File.Exists(path)) File.WriteAllText(path, ".idea\n.vs\nbin\nobj\n/Library\n/Temp\n/UserSettings\n/Configs\n/*.csproj\n/*.sln\n/Logs\n/Packages/*\n!/Packages/manifest.json\n!/Packages/packages-lock.json\n~UnityDirMonSyncFile~*");
     }
 
+    private void ExportPackageInventory() 
+        {
+            string rootPath = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
+            string outputPath = Path.Combine(rootPath, "PACKAGES.md");
+            
+            string unityManifest = Path.Combine(rootPath, "Packages", "manifest.json");
+            string vpmManifest = Path.Combine(rootPath, "Packages", "vpm-manifest.json");
+
+            List<string> mdLines = new List<string>();
+            mdLines.Add("# 📦 Project Dependencies Inventory");
+            mdLines.Add($"\n*Last Update: {System.DateTime.Now:yyyy-MM-dd HH:mm:ss}*");
+            mdLines.Add("\n> [!TIP]\n> This list helps to restore the workspace if the Creator Companion or Unity fails to auto-resolve dependencies.\n");
+
+            int totalFound = 0;
+
+            totalFound += ParseManifest(unityManifest, "Unity Standard & Scoped Dependencies", mdLines);
+            totalFound += ParseManifest(vpmManifest, "VRChat Package Manager (VPM) Dependencies", mdLines);
+
+            try {
+                File.WriteAllLines(outputPath, mdLines, System.Text.Encoding.UTF8);
+                RunGitCommand($"add \"{outputPath}\"");
+                UnityEngine.Debug.Log($"Git-Tool: PACKAGES.md aktualisiert. {totalFound} Einträge gefunden.");
+            } catch (System.Exception e) {
+                UnityEngine.Debug.LogError("Git-Tool: Fehler beim Schreiben der PACKAGES.md: " + e.Message);
+            }
+        }
+
+        private int ParseManifest(string path, string sectionTitle, List<string> outputList)
+        {
+            if (!File.Exists(path)) return 0;
+
+            int count = 0;
+            try {
+                string content = File.ReadAllText(path);
+                
+                // 1. Finde den Start des "dependencies" Blocks
+                int startIndex = content.IndexOf("\"dependencies\"");
+                if (startIndex == -1) return 0; 
+                
+                // Finde die erste öffnende Klammer nach dem Wort
+                startIndex = content.IndexOf("{", startIndex);
+                if (startIndex == -1) return 0;
+
+                // 2. Extrahiere exakt diesen Block, indem wir Klammern zählen
+                int openBraces = 0;
+                int endIndex = startIndex;
+                for (int i = startIndex; i < content.Length; i++) {
+                    if (content[i] == '{') openBraces++;
+                    if (content[i] == '}') {
+                        openBraces--;
+                        // Sobald wir wieder bei 0 sind, ist der Dependencies-Block geschlossen
+                        if (openBraces == 0) {
+                            endIndex = i;
+                            break;
+                        }
+                    }
+                }
+
+                if (endIndex <= startIndex) return 0;
+
+                // Header nur zeichnen, wenn wir wirklich einen Block haben
+                outputList.Add($"## {sectionTitle}");
+                outputList.Add("| Package Name | Version / Source |");
+                outputList.Add("| :--- | :--- |");
+
+                // Den isolierten Block herauslösen und in Zeilen splitten
+                string dependenciesBlock = content.Substring(startIndex, endIndex - startIndex + 1);
+                string[] blockLines = dependenciesBlock.Split(new[] { '\r', '\n' }, System.StringSplitOptions.RemoveEmptyEntries);
+                
+                string currentVpmPackage = "";
+
+                // 3. Den sauberen Block auswerten
+                foreach (string line in blockLines) {
+                    string trimmed = line.Trim();
+                    
+                    // Einzelne Klammern können wir ignorieren, da wir eh schon im richtigen Block sind
+                    if (trimmed == "{" || trimmed == "}" || trimmed == "},") continue;
+
+                    if (trimmed.StartsWith("\"")) {
+                        string[] parts = trimmed.Split(new char[] { ':' }, 2);
+                        if (parts.Length == 2) {
+                            string key = parts[0].Replace("\"", "").Trim();
+                            string rawValue = parts[1].Trim();
+
+                            if (rawValue.StartsWith("{")) {
+                                // VPM Paket Start (z.B. "com.vrchat.base": { )
+                                currentVpmPackage = key;
+                            } 
+                            else if (key == "version") {
+                                // VPM Paket Version (z.B. "version": "3.10.2")
+                                string val = rawValue.Replace("\"", "").Replace(",", "").Trim();
+                                if (!string.IsNullOrEmpty(currentVpmPackage)) {
+                                    outputList.Add($"| `{currentVpmPackage}` | {val} |");
+                                    count++;
+                                    currentVpmPackage = "";
+                                }
+                            }
+                            else if (!rawValue.StartsWith("{")) {
+                                // Unity Flat Paket (z.B. "com.unity.timeline": "1.2.3")
+                                string val = rawValue.Replace("\"", "").Replace(",", "").Trim();
+                                outputList.Add($"| `{key}` | {val} |");
+                                count++;
+                            }
+                        }
+                    }
+                }
+            } catch (System.Exception e) { 
+                UnityEngine.Debug.LogWarning($"Git-Tool: Warnung beim Lesen von {Path.GetFileName(path)}: {e.Message}"); 
+            }
+
+            if (count == 0) {
+                outputList.Add("| - | No entries found |");
+            }
+            
+            outputList.Add(""); // Leerzeile für sauberes Markdown
+            return count;
+        }
+
     // FIX: Methode ist wieder static!
     public static string RunGitCommand(string args, bool logAction = false) {
         try {

Editor/LiveSyncPanel.cs

@@ -0,0 +1,218 @@
+using UnityEditor;
+using UnityEngine;
+using System;
+using System.Text;
+using System.Threading;
+using System.Net.WebSockets;
+using System.Threading.Tasks;
+
+public class LiveSyncPanel : EditorWindow
+{
+    private string wsUrl = "ws://localhost:8080";
+    private static ClientWebSocket ws;
+    private static bool isConnected = false;
+    private static CancellationTokenSource cts;
+
+    private Transform lastSelected;
+    private bool isNetworkApplying = false;
+
+    [Serializable]
+    private class SyncMessage
+    {
+        public string type; 
+        public string objectName;
+        public Vector3 position;
+        public Vector3 eulerAngles;
+        public Vector3 localScale;
+    }
+
+    [MenuItem("Tools/MrUnknownDE/Live Sync Bridge")]
+    public static void ShowWindow()
+    {
+        GetWindow<LiveSyncPanel>("Live Sync Bridge").minSize = new Vector2(320, 350);
+    }
+
+    private void OnEnable()
+    {
+        wsUrl = EditorPrefs.GetString("LiveSync_WS_URL", "ws://localhost:8080");
+        EditorApplication.update += EditorUpdate;
+        Selection.selectionChanged += OnSelectionChanged;
+    }
+
+    private void OnDisable()
+    {
+        EditorApplication.update -= EditorUpdate;
+        Selection.selectionChanged -= OnSelectionChanged;
+    }
+
+    private void OnGUI()
+    {
+        GUILayout.Space(5);
+
+        // --- 🚧 DICK & FETT: WIP WARNING 🚧 ---
+        EditorGUILayout.HelpBox(
+            "🚧 WORK IN PROGRESS 🚧\n\n" +
+            "This feature is highly experimental and in active development!\n" +
+            "Expect bugs, network desyncs, or unexpected behavior.\n\n" +
+            "ALWAYS backup your project before starting a Live Session!", 
+            MessageType.Warning);
+        
+        GUILayout.Space(10);
+        GUILayout.Label("REAL-TIME MULTI-USER SYNC", EditorStyles.boldLabel);
+        GUILayout.Space(10);
+
+        EditorGUI.BeginChangeCheck();
+        wsUrl = EditorGUILayout.TextField("WebSocket Server:", wsUrl);
+        if (EditorGUI.EndChangeCheck())
+        {
+            EditorPrefs.SetString("LiveSync_WS_URL", wsUrl);
+        }
+
+        GUILayout.Space(15);
+
+        if (!isConnected)
+        {
+            GUI.backgroundColor = new Color(0.2f, 0.6f, 0.2f);
+            if (GUILayout.Button("🔌 Connect Session", GUILayout.Height(40))) Connect();
+        }
+        else
+        {
+            GUI.backgroundColor = new Color(0.8f, 0.3f, 0.3f);
+            if (GUILayout.Button("🛑 Disconnect", GUILayout.Height(40))) Disconnect();
+
+            GUILayout.Space(15);
+            EditorGUILayout.HelpBox("🟢 Connected!\nTransforms are tracked in real-time.\nListening for Git updates...", MessageType.Info);
+        }
+        GUI.backgroundColor = Color.white;
+    }
+
+    private async void Connect()
+    {
+        if (ws != null && ws.State == WebSocketState.Open) return;
+
+        ws = new ClientWebSocket();
+        cts = new CancellationTokenSource();
+
+        try
+        {
+            await ws.ConnectAsync(new Uri(wsUrl), cts.Token);
+            isConnected = true;
+            UnityEngine.Debug.Log("Live Sync: Connected to Server!");
+            
+            _ = ReceiveLoop();
+        }
+        catch (Exception e)
+        {
+            UnityEngine.Debug.LogError("Live Sync: Connection failed. Is the server running? " + e.Message);
+        }
+    }
+
+    private async void Disconnect()
+    {
+        if (ws != null)
+        {
+            cts?.Cancel();
+            if (ws.State == WebSocketState.Open) await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Client disconnecting", CancellationToken.None);
+            ws.Dispose();
+        }
+        isConnected = false;
+        UnityEngine.Debug.Log("Live Sync: Disconnected.");
+    }
+
+    private void EditorUpdate()
+    {
+        if (!isConnected || isNetworkApplying) return;
+
+        if (lastSelected != null && lastSelected.hasChanged)
+        {
+            SyncMessage msg = new SyncMessage
+            {
+                type = "TRANSFORM",
+                objectName = lastSelected.name,
+                position = lastSelected.position,
+                eulerAngles = lastSelected.eulerAngles,
+                localScale = lastSelected.localScale
+            };
+
+            SendMessage(JsonUtility.ToJson(msg));
+            lastSelected.hasChanged = false; 
+        }
+    }
+
+    private void OnSelectionChanged()
+    {
+        if (Selection.activeTransform != null)
+        {
+            lastSelected = Selection.activeTransform;
+            lastSelected.hasChanged = false; 
+        }
+    }
+
+    public static void BroadcastGitUpdate()
+    {
+        if (!isConnected || ws == null || ws.State != WebSocketState.Open) return;
+
+        SyncMessage msg = new SyncMessage { type = "GIT_PULL" };
+        SendMessage(JsonUtility.ToJson(msg));
+        UnityEngine.Debug.Log("Live Sync: Broadcasted Git Update signal to team.");
+    }
+
+    private static async void SendMessage(string json)
+    {
+        if (ws == null || ws.State != WebSocketState.Open) return;
+        byte[] bytes = Encoding.UTF8.GetBytes(json);
+        await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, cts.Token);
+    }
+
+    private async Task ReceiveLoop()
+    {
+        byte[] buffer = new byte[2048];
+        while (ws.State == WebSocketState.Open)
+        {
+            try
+            {
+                var result = await ws.ReceiveAsync(new ArraySegment<byte>(buffer), cts.Token);
+                if (result.MessageType == WebSocketMessageType.Text)
+                {
+                    string json = Encoding.UTF8.GetString(buffer, 0, result.Count);
+                    EditorApplication.delayCall += () => ProcessIncoming(json);
+                }
+            }
+            catch { break; }
+        }
+        isConnected = false;
+    }
+
+    private void ProcessIncoming(string json)
+    {
+        try
+        {
+            SyncMessage msg = JsonUtility.FromJson<SyncMessage>(json);
+
+            if (msg.type == "TRANSFORM")
+            {
+                GameObject target = GameObject.Find(msg.objectName);
+                if (target != null)
+                {
+                    isNetworkApplying = true; 
+                    target.transform.position = msg.position;
+                    target.transform.eulerAngles = msg.eulerAngles;
+                    target.transform.localScale = msg.localScale;
+                    target.transform.hasChanged = false;
+                    isNetworkApplying = false;
+                }
+            }
+            else if (msg.type == "GIT_PULL")
+            {
+                UnityEngine.Debug.LogWarning("Live Sync: Teammate pushed new files! Starting auto-pull...");
+                GitPanel.RunGitCommand("pull --rebase origin HEAD");
+                AssetDatabase.Refresh();
+                UnityEngine.Debug.Log("Live Sync: Auto-pull complete. Files updated.");
+            }
+        }
+        catch (Exception e)
+        {
+            UnityEngine.Debug.LogWarning("Live Sync: Failed to parse incoming message. " + e.Message);
+        }
+    }
+}

README.md

@@ -55,7 +55,7 @@ This tool is installed manually directly into your Unity project.
 
 Once installed, you can access the tools via the top menu bar in Unity:
 
-`Tools` -> `MrUnknownDE` -> `GIT Version Control`
+`Tools` -> `MrUnknownDE` -> `GIT Version Control`<br>
 `Tools` -> `MrUnknownDE` -> `Discord RPC`
 
 The tools will open as floating windows. You can easily dock them into your custom Unity layout (e.g., right next to the Inspector or Console).