je-editor 0.0.210__tar.gz → 0.0.212__tar.gz

{je_editor-0.0.210 → je_editor-0.0.212}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: je_editor
-Version: 0.0.210
+Version: 0.0.212
 Summary: JEditor is basic but powerful editor include GPT
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/JE-Chen/je_editor
@@ -16,7 +16,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: PySide6==6.9.1
+Requires-Dist: PySide6==6.9.2
 Requires-Dist: qt-material
 Requires-Dist: yapf
 Requires-Dist: frontengine
@@ -26,6 +26,8 @@ Requires-Dist: qtconsole
 Requires-Dist: langchain_openai
 Requires-Dist: langchain
 Requires-Dist: pydantic
+Requires-Dist: watchdog
+Requires-Dist: ruff
 Dynamic: license-file
 
 # je_editor

je_editor-0.0.212/je_editor/code_scan/ruff_thread.py

@@ -0,0 +1,31 @@
+import subprocess
+import threading
+import time
+from queue import Queue
+
+
+class RuffThread(threading.Thread):
+
+    def __init__(self, ruff_commands: list, std_queue: Queue, stderr_queue: Queue):
+        super().__init__()
+        if ruff_commands is None:
+            self.ruff_commands = ["ruff", "check"]
+        else:
+            self.ruff_commands = ruff_commands
+        self.ruff_process = None
+        self.std_queue = std_queue
+        self.stderr_queue = stderr_queue
+
+    def run(self):
+        self.ruff_process = subprocess.Popen(
+            self.ruff_commands, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+        while self.ruff_process.poll() is None:
+            time.sleep(1)
+        else:
+            for line in self.ruff_process.stdout:
+                print(line.strip())
+            for line in self.ruff_process.stderr:
+                print(line.strip())
+
+
+

je_editor-0.0.212/je_editor/code_scan/watchdog_implement.py

@@ -0,0 +1,34 @@
+from queue import Queue
+
+from watchdog.events import FileSystemEventHandler
+
+from je_editor.code_scan.ruff_thread import RuffThread
+
+
+class RuffPythonFileChangeHandler(FileSystemEventHandler):
+
+    def __init__(self, ruff_commands: list = None):
+        super(RuffPythonFileChangeHandler, self).__init__()
+        self.ruff_commands = ruff_commands
+        self.stdout_queue = Queue()
+        self.stderr_queue = Queue()
+        self.ruff_threads_dict = dict()
+
+    def on_modified(self, event):
+        if event.is_directory:
+            return
+        if event.src_path.endswith(".py"):
+            if self.ruff_threads_dict.get(event.src_path) is None:
+                ruff_thread = RuffThread(self.ruff_commands, self.stdout_queue, self.stderr_queue)
+                self.ruff_threads_dict.update({event.src_path: ruff_thread})
+                ruff_thread.start()
+            else:
+                ruff_thread = self.ruff_threads_dict.get(event.src_path)
+                if not ruff_thread.is_alive():
+                    ruff_thread = RuffThread(self.ruff_commands, self.stdout_queue, self.stderr_queue)
+                    self.ruff_threads_dict.update({event.src_path: ruff_thread})
+                    ruff_thread.start()
+                else:
+                    pass
+
+

je_editor-0.0.212/je_editor/code_scan/watchdog_thread.py

@@ -0,0 +1,33 @@
+import threading
+import time
+
+from watchdog.observers import Observer
+
+from je_editor.code_scan.watchdog_implement import RuffPythonFileChangeHandler
+
+
+class WatchdogThread(threading.Thread):
+
+    def __init__(self, check_path: str):
+        super().__init__()
+        self.check_path = check_path
+        self.ruff_handler = RuffPythonFileChangeHandler()
+        self.running = True
+
+    def run(self):
+        observer = Observer()
+        observer.schedule(self.ruff_handler, str(self.check_path), recursive=True)
+        observer.start()
+        try:
+            while self.running:
+                time.sleep(1)
+        finally:
+            observer.stop()
+
+
+if __name__ == '__main__':
+    watchdog_thread = WatchdogThread(".")
+    watchdog_thread.start()
+    while True:
+        time.sleep(1)
+

je_editor-0.0.212/je_editor/pyside_ui/code/variable_inspector/inspector_gui.py

@@ -0,0 +1,122 @@
+import ast
+
+from PySide6.QtCore import QAbstractTableModel, Qt, QTimer, QSortFilterProxyModel
+from PySide6.QtWidgets import QTableView, QVBoxLayout, QWidget, QLineEdit, QLabel
+
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+
+
+class VariableModel(QAbstractTableModel):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.variables = []
+
+    def update_data(self):
+        parent_widget = self.parent()
+        if parent_widget and getattr(parent_widget, "table", None):
+            if parent_widget.table.state() != QTableView.State.NoState:
+                return
+
+        vars_dict = globals()
+        self.beginResetModel()
+        self.variables = [
+            [name, type(value).__name__, repr(value), value]
+            for name, value in vars_dict.items()
+            if not name.startswith("__")  # 過濾內建變數
+        ]
+        self.endResetModel()
+
+    def rowCount(self, parent=None):
+        return len(self.variables)
+
+    def columnCount(self, parent=None):
+        return 3
+
+    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid() or not (0 <= index.row() < len(self.variables)):
+            return None
+        if role == Qt.ItemDataRole.DisplayRole:
+            return self.variables[index.row()][index.column()]
+        return None
+
+    def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
+        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
+            return [
+                language_wrapper.language_word_dict.get("variable_inspector_var_name"),
+                language_wrapper.language_word_dict.get("variable_inspector_var_type"),
+                language_wrapper.language_word_dict.get("variable_inspector_var_value")
+            ][section]
+        return None
+
+    def flags(self, index):
+        if not index.isValid() or not (0 <= index.row() < len(self.variables)):
+            return Qt.ItemFlag.NoItemFlags
+        base = super().flags(index)
+        if index.column() == 2:  # 只允許編輯值欄
+            base |= Qt.ItemFlag.ItemIsEditable
+        return base
+
+    def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
+        if role == Qt.ItemDataRole.EditRole and index.column() == 2:
+
+            if value == "":
+                return False
+
+            old_repr = self.variables[index.row()][2]
+            if str(value) == old_repr:
+                return False
+
+            var_name = self.variables[index.row()][0]
+            try:
+                new_value = ast.literal_eval(value)
+            except Exception:
+                new_value = value
+
+            if new_value == self.variables[index.row()][3]:
+                return False
+
+            globals()[var_name] = new_value
+            self.variables[index.row()][2] = repr(new_value)
+            self.variables[index.row()][3] = new_value
+            self.dataChanged.emit(index, index, [Qt.ItemDataRole.DisplayRole])
+            return True
+        return False
+
+class VariableProxy(QSortFilterProxyModel):
+    def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
+        return self.sourceModel().setData(
+            self.mapToSource(index), value, role
+        )
+
+class VariableInspector(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle(language_wrapper.language_word_dict.get("variable_inspector_title"))
+        layout = QVBoxLayout(self)
+
+        self.search_box = QLineEdit()
+        self.search_box.setPlaceholderText(language_wrapper.language_word_dict.get("variable_inspector_search"))
+        layout.addWidget(QLabel(language_wrapper.language_word_dict.get("variable_inspector_search")))
+        layout.addWidget(self.search_box)
+
+        self.model = VariableModel(parent=self)
+        self.proxy_model = VariableProxy(self)
+        self.proxy_model.setSourceModel(self.model)
+        self.proxy_model.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self.proxy_model.setFilterKeyColumn(0)
+
+        self.table = QTableView()
+        self.table.setModel(self.proxy_model)
+        self.table.horizontalHeader().setStretchLastSection(True)
+        self.table.horizontalHeader().setSectionResizeMode(
+            self.table.horizontalHeader().ResizeMode.Stretch
+        )
+        layout.addWidget(self.table, stretch=1)
+
+        self.search_box.textChanged.connect(
+            self.proxy_model.setFilterFixedString
+        )
+
+        self.timer = QTimer(self)
+        self.timer.timeout.connect(self.model.update_data)
+        self.timer.start(500)

je_editor-0.0.212/je_editor/pyside_ui/main_ui/console_widget/console_gui.py

@@ -0,0 +1,130 @@
+import os
+
+from PySide6.QtCore import Qt, QEvent
+from PySide6.QtGui import QTextCursor, QColor, QKeyEvent
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QPlainTextEdit, QLineEdit,
+    QPushButton, QLabel, QFileDialog, QComboBox
+)
+
+from je_editor.pyside_ui.main_ui.console_widget.qprocess_adapter import ConsoleProcessAdapter
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+
+
+class ConsoleWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.language_word_dict_get = language_wrapper.language_word_dict.get
+        self.proc = ConsoleProcessAdapter(self)
+        self.proc.stdout.connect(self.append_text)
+        self.proc.stderr.connect(lambda t: self.append_text(t, "#d33"))
+        self.proc.system.connect(
+            lambda t: self.append_text(f"{self.language_word_dict_get('dynamic_console_system_prefix')}{t}\n", "#888"))
+        self.proc.started.connect(lambda: self.proc.system.emit(self.language_word_dict_get("dynamic_console_running")))
+        self.proc.finished.connect(self.on_finished)
+
+        self.history, self.history_index = [], -1
+
+        self.output = QPlainTextEdit(readOnly=True)
+        self.output.setMaximumBlockCount(10000)
+        self.output.setStyleSheet("font-family: Consolas, monospace;")
+
+        self.input = QLineEdit()
+        self.input.setPlaceholderText("Enter command")
+        self.input.returnPressed.connect(self.run_command)
+        self.input.installEventFilter(self)
+
+        self.btn_run = QPushButton(self.language_word_dict_get("dynamic_console_run"))
+        self.btn_run.clicked.connect(self.run_command)
+        self.btn_stop = QPushButton(self.language_word_dict_get("dynamic_console_stop"))
+        self.btn_stop.clicked.connect(self.proc.stop)
+        self.btn_clear = QPushButton(self.language_word_dict_get("dynamic_console_clear"))
+        self.btn_clear.clicked.connect(self.output.clear)
+
+        self.cwd_label = QLabel(f"{self.language_word_dict_get('dynamic_console_cwd')}: {os.getcwd()}")
+        self.btn_pick_cwd = QPushButton("…")
+        self.btn_pick_cwd.clicked.connect(self.pick_cwd)
+
+        self.shell_combo = QComboBox()
+        self.shell_combo.addItems(["auto", "cmd", "powershell", "bash", "sh"])
+
+        top = QHBoxLayout()
+        top.addWidget(self.cwd_label)
+        top.addWidget(self.btn_pick_cwd)
+        top.addStretch()
+        top.addWidget(QLabel(self.language_word_dict_get("dynamic_console_shell")))
+        top.addWidget(self.shell_combo)
+
+        mid = QHBoxLayout()
+        mid.addWidget(self.input, 1)
+        mid.addWidget(self.btn_run)
+        mid.addWidget(self.btn_stop)
+        mid.addWidget(self.btn_clear)
+
+        lay = QVBoxLayout(self)
+        lay.addLayout(top)
+        lay.addWidget(self.output, 1)
+        lay.addLayout(mid)
+
+        self.proc.system.emit(self.language_word_dict_get("dynamic_console_ready"))
+        # 啟動互動式 shell
+        self.proc.start_shell(self.shell_combo.currentText())
+
+    def eventFilter(self, obj, event):
+        if obj is self.input and isinstance(event, QKeyEvent) and event.type() == QEvent.Type.KeyPress:
+            if event.key() == Qt.Key.Key_Up:
+                self.history_prev()
+                return True
+            if event.key() == Qt.Key.Key_Down:
+                self.history_next()
+                return True
+        return super().eventFilter(obj, event)
+
+    def history_prev(self):
+        if not self.history: return
+        self.history_index = len(self.history) - 1 if self.history_index < 0 else max(0, self.history_index - 1)
+        self.input.setText(self.history[self.history_index])
+        self.input.end(False)
+
+    def history_next(self):
+        if not self.history: return
+        if self.history_index < 0: return
+        self.history_index += 1
+        if self.history_index >= len(self.history):
+            self.history_index = -1
+            self.input.clear()
+        else:
+            self.input.setText(self.history[self.history_index])
+            self.input.end(False)
+
+    def pick_cwd(self):
+        d = QFileDialog.getExistingDirectory(self, "Select working directory", os.getcwd())
+        if d:
+            self.proc.set_cwd(d)
+            self.cwd_label.setText(f"{self.language_word_dict_get('dynamic_console_cwd')}: {d}")
+            self.proc.system.emit(f'cd "{d}"')
+
+    def append_text(self, text, color=None):
+        cursor = self.output.textCursor()
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        fmt = self.output.currentCharFormat()
+        if color: fmt.setForeground(QColor(color))
+        cursor.setCharFormat(fmt)
+        cursor.insertText(text)
+        self.output.setTextCursor(cursor)
+        self.output.ensureCursorVisible()
+
+    def run_command(self):
+        cmd = self.input.text().strip()
+        if not cmd: return
+        if not self.history or self.history[-1] != cmd:
+            self.history.append(cmd)
+        self.history_index = -1
+        self.append_text(f"{self.language_word_dict_get('dynamic_console_prompt')}{cmd}\n", "#0aa")
+        self.proc.send_command(cmd)
+        self.input.clear()
+
+    def on_finished(self, code, status):
+        self.append_text(f"\n{self.language_word_dict_get('dynamic_console_done').format(code=code, status=status)}\n",
+                         "#888")
+        self.proc.system.emit(self.language_word_dict_get("dynamic_console_ready"))

je_editor-0.0.212/je_editor/pyside_ui/main_ui/console_widget/qprocess_adapter.py

@@ -0,0 +1,63 @@
+import os
+
+from PySide6.QtCore import QObject, QProcess, Signal, QTimer
+
+
+class ConsoleProcessAdapter(QObject):
+    started = Signal()
+    finished = Signal(int, QProcess.ExitStatus)
+    stdout = Signal(str)
+    stderr = Signal(str)
+    system = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.proc = QProcess(self)
+        self.proc.setProcessChannelMode(QProcess.ProcessChannelMode.SeparateChannels)
+        self.proc.readyReadStandardOutput.connect(self._on_stdout)
+        self.proc.readyReadStandardError.connect(self._on_stderr)
+        self.proc.started.connect(self.started)
+        self.proc.finished.connect(self.finished)
+
+    def set_cwd(self, path: str):
+        self.proc.setWorkingDirectory(path)
+
+    def start_shell(self, shell: str = "auto"):
+        if self.is_running():
+            self.system.emit("Shell already running")
+            return
+        program, args = self._build_shell_command(shell)
+        self.proc.start(program, args)
+
+        if os.name == "nt":
+            QTimer.singleShot(500, lambda: self.send_command("chcp 65001"))
+
+    def send_command(self, cmd: str):
+        if not self.is_running():
+            self.system.emit("Shell not running")
+            return
+        self.proc.write((cmd + "\n").encode("utf-8"))
+
+    def stop(self):
+        if not self.is_running():
+            return
+        self.proc.terminate()
+        QTimer.singleShot(1000, lambda: self.is_running() and self.proc.kill())
+
+    def is_running(self):
+        return self.proc.state() != QProcess.ProcessState.NotRunning
+
+    def _on_stdout(self):
+        self.stdout.emit(bytes(self.proc.readAllStandardOutput()).decode("utf-8", errors="replace"))
+
+    def _on_stderr(self):
+        self.stderr.emit(bytes(self.proc.readAllStandardError()).decode("utf-8", errors="replace"))
+
+    def _build_shell_command(self, shell: str):
+        if shell == "auto":
+            shell = "cmd" if os.name == "nt" else "bash"
+        if os.name == "nt":
+            if shell == "powershell":
+                return "powershell.exe", ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass"]
+            return "cmd.exe", []
+        return ("/bin/bash" if shell == "bash" else "/bin/sh"), []

{je_editor-0.0.210 → je_editor-0.0.212}/je_editor/pyside_ui/main_ui/menu/dock_menu/build_dock_menu.py

@@ -9,7 +9,11 @@ from PySide6.QtWidgets import QFileDialog
 from frontengine import FrontEngineMainUI
 
 from je_editor.pyside_ui.browser.browser_widget import BrowserWidget
+from je_editor.pyside_ui.code.variable_inspector.inspector_gui import VariableInspector
+from je_editor.pyside_ui.git.git_branch_tree_widget import GitTreeViewGUI
+from je_editor.pyside_ui.git.git_client_gui import Gitgui
 from je_editor.pyside_ui.main_ui.ai_widget.chat_ui import ChatUI
+from je_editor.pyside_ui.main_ui.console_widget.console_gui import ConsoleWidget
 from je_editor.pyside_ui.main_ui.dock.destroy_dock import DestroyDock
 from je_editor.pyside_ui.main_ui.editor.editor_widget_dock import FullEditorWidget
 from je_editor.pyside_ui.main_ui.ipython_widget.rich_jupyter import IpythonWidget
@@ -67,6 +71,34 @@ def set_dock_menu(ui_we_want_to_set: EditorMain) -> None:
         lambda: add_dock_widget(ui_we_want_to_set, "chat_ui")
     )
     ui_we_want_to_set.dock_menu.addAction(ui_we_want_to_set.dock_menu.new_chat_ui)
+    # Git Client
+    ui_we_want_to_set.dock_menu.new_git_client = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_git_client_tab_name"))
+    ui_we_want_to_set.dock_menu.new_git_client.triggered.connect(
+        lambda: add_dock_widget(ui_we_want_to_set, "git_client")
+    )
+    ui_we_want_to_set.dock_menu.addAction(ui_we_want_to_set.dock_menu.new_git_client)
+    # Git branch tree view
+    ui_we_want_to_set.dock_menu.new_git_branch_view = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_git_branch_tree_view_tab_name"))
+    ui_we_want_to_set.dock_menu.new_git_branch_view.triggered.connect(
+        lambda: add_dock_widget(ui_we_want_to_set, "git_branch_tree_view")
+    )
+    ui_we_want_to_set.dock_menu.addAction(ui_we_want_to_set.dock_menu.new_git_branch_view)
+    # Variable Inspector
+    ui_we_want_to_set.dock_menu.new_variable_inspector = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_variable_inspector_tab_name"))
+    ui_we_want_to_set.dock_menu.new_variable_inspector.triggered.connect(
+        lambda: add_dock_widget(ui_we_want_to_set, "variable_inspector")
+    )
+    ui_we_want_to_set.dock_menu.addAction(ui_we_want_to_set.dock_menu.new_variable_inspector)
+    # Dynamic Console
+    ui_we_want_to_set.dock_menu.new_dynamic_console = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_console_widget_tab_name"))
+    ui_we_want_to_set.dock_menu.new_dynamic_console.triggered.connect(
+        lambda: add_dock_widget(ui_we_want_to_set, "console_widget")
+    )
+    ui_we_want_to_set.dock_menu.addAction(ui_we_want_to_set.dock_menu.new_dynamic_console)
 
 def add_dock_widget(ui_we_want_to_set: EditorMain, widget_type: str = None):
     jeditor_logger.info("build_dock_menu.py add_dock_widget "
@@ -100,6 +132,18 @@ def add_dock_widget(ui_we_want_to_set: EditorMain, widget_type: str = None):
     elif widget_type == "chat_ui":
         dock_widget.setWindowTitle(language_wrapper.language_word_dict.get("chat_ui_dock_label"))
         dock_widget.setWidget(ChatUI(ui_we_want_to_set))
+    elif widget_type == "git_client":
+        dock_widget.setWindowTitle(language_wrapper.language_word_dict.get("tab_menu_git_client_tab_name"))
+        dock_widget.setWidget(Gitgui())
+    elif widget_type == "git_branch_tree_view":
+        dock_widget.setWindowTitle(language_wrapper.language_word_dict.get("tab_menu_git_branch_tree_view_tab_name"))
+        dock_widget.setWidget(GitTreeViewGUI())
+    elif widget_type == "variable_inspector":
+        dock_widget.setWindowTitle(language_wrapper.language_word_dict.get("tab_menu_variable_inspector_tab_name"))
+        dock_widget.setWidget(VariableInspector())
+    elif widget_type == "console_widget":
+        dock_widget.setWindowTitle(language_wrapper.language_word_dict.get("tab_menu_console_widget_tab_name"))
+        dock_widget.setWidget(ConsoleWidget())
     else:
         dock_widget.setWindowTitle(language_wrapper.language_word_dict.get("dock_browser_title"))
         dock_widget.setWidget(BrowserWidget())

{je_editor-0.0.210 → je_editor-0.0.212}/je_editor/pyside_ui/main_ui/menu/tab_menu/build_tab_menu.py

@@ -5,7 +5,11 @@ from typing import TYPE_CHECKING
 from frontengine import FrontEngineMainUI
 
 from je_editor.pyside_ui.browser.browser_widget import BrowserWidget
+from je_editor.pyside_ui.code.variable_inspector.inspector_gui import VariableInspector
+from je_editor.pyside_ui.git.git_branch_tree_widget import GitTreeViewGUI
+from je_editor.pyside_ui.git.git_client_gui import Gitgui
 from je_editor.pyside_ui.main_ui.ai_widget.chat_ui import ChatUI
+from je_editor.pyside_ui.main_ui.console_widget.console_gui import ConsoleWidget
 from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
 from je_editor.pyside_ui.main_ui.ipython_widget.rich_jupyter import IpythonWidget
 from je_editor.utils.logging.loggin_instance import jeditor_logger
@@ -63,10 +67,37 @@ def set_tab_menu(ui_we_want_to_set: EditorMain) -> None:
         lambda: add_chat_ui_tab(ui_we_want_to_set)
     )
     ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_chat_ui_action)
-
+    # Git Client
+    ui_we_want_to_set.tab_menu.add_git_client_ui_action = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_git_client_tab_name"))
+    ui_we_want_to_set.tab_menu.add_git_client_ui_action.triggered.connect(
+        lambda: add_git_client_tab(ui_we_want_to_set)
+    )
+    ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_git_client_ui_action)
+    # Git Branch tree
+    ui_we_want_to_set.tab_menu.add_git_branch_view_ui_action = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_git_branch_tree_view_tab_name"))
+    ui_we_want_to_set.tab_menu.add_git_branch_view_ui_action.triggered.connect(
+        lambda: add_git_tree_view_tab(ui_we_want_to_set)
+    )
+    ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_git_branch_view_ui_action)
+    # Variable Inspector
+    ui_we_want_to_set.tab_menu.add_variable_inspector_ui_action = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_variable_inspector_tab_name"))
+    ui_we_want_to_set.tab_menu.add_variable_inspector_ui_action.triggered.connect(
+        lambda: add_variable_inspector_tab(ui_we_want_to_set)
+    )
+    ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_variable_inspector_ui_action)
+    # Dynamic Console
+    ui_we_want_to_set.tab_menu.add_console_widget_ui_action = QAction(
+        language_wrapper.language_word_dict.get("tab_menu_console_widget_tab_name"))
+    ui_we_want_to_set.tab_menu.add_console_widget_ui_action.triggered.connect(
+        lambda: add_console_widget_tab(ui_we_want_to_set)
+    )
+    ui_we_want_to_set.tab_menu.addAction(ui_we_want_to_set.tab_menu.add_console_widget_ui_action)
 
 def add_editor_tab(ui_we_want_to_set: EditorMain):
-    jeditor_logger.info(f"build_tab_menu.py add_editor_tab ui_we_want_to_set: {ui_we_want_to_set}")
+    jeditor_logger.info(f"build_tab_menu.py add editor tab ui_we_want_to_set: {ui_we_want_to_set}")
     widget = EditorWidget(ui_we_want_to_set)
     ui_we_want_to_set.tab_widget.addTab(
         widget,
@@ -76,7 +107,7 @@ def add_editor_tab(ui_we_want_to_set: EditorMain):
 
 
 def add_frontengine_tab(ui_we_want_to_set: EditorMain):
-    jeditor_logger.info(f"build_tab_menu.py add_frontengine_tab ui_we_want_to_set: {ui_we_want_to_set}")
+    jeditor_logger.info(f"build_tab_menu.py add frontengine tab ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.tab_widget.addTab(
         FrontEngineMainUI(show_system_tray_ray=False, redirect_output=False),
         f"{language_wrapper.language_word_dict.get('tab_menu_frontengine_tab_name')} "
@@ -84,7 +115,7 @@ def add_frontengine_tab(ui_we_want_to_set: EditorMain):
 
 
 def add_web_tab(ui_we_want_to_set: EditorMain):
-    jeditor_logger.info(f"build_tab_menu.py add_web_tab ui_we_want_to_set: {ui_we_want_to_set}")
+    jeditor_logger.info(f"build_tab_menu.py add web tab ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.tab_widget.addTab(
         BrowserWidget(),
         f"{language_wrapper.language_word_dict.get('tab_menu_web_tab_name')} "
@@ -92,7 +123,7 @@ def add_web_tab(ui_we_want_to_set: EditorMain):
 
 
 def add_stackoverflow_tab(ui_we_want_to_set: EditorMain):
-    jeditor_logger.info(f"build_tab_menu.py add_stackoverflow_tab ui_we_want_to_set: {ui_we_want_to_set}")
+    jeditor_logger.info(f"build_tab_menu.py add stackoverflow tab ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.tab_widget.addTab(
         BrowserWidget(start_url="https://stackoverflow.com/", search_prefix="https://stackoverflow.com/search?q="),
         f"{language_wrapper.language_word_dict.get('tab_menu_stackoverflow_tab_name')} "
@@ -100,7 +131,7 @@ def add_stackoverflow_tab(ui_we_want_to_set: EditorMain):
 
 
 def add_ipython_tab(ui_we_want_to_set: EditorMain):
-    jeditor_logger.info(f"build_tab_menu.py add_ipython_tab ui_we_want_to_set: {ui_we_want_to_set}")
+    jeditor_logger.info(f"build_tab_menu.py add ipython tab ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.tab_widget.addTab(
         IpythonWidget(ui_we_want_to_set),
         f"{language_wrapper.language_word_dict.get('tab_menu_ipython_tab_name')} "
@@ -108,10 +139,38 @@ def add_ipython_tab(ui_we_want_to_set: EditorMain):
 
 
 def add_chat_ui_tab(ui_we_want_to_set: EditorMain):
-    jeditor_logger.info(f"build_tab_menu.py add_ipython_tab ui_we_want_to_set: {ui_we_want_to_set}")
+    jeditor_logger.info(f"build_tab_menu.py add chat_ui tab ui_we_want_to_set: {ui_we_want_to_set}")
     ui_we_want_to_set.tab_widget.addTab(
         ChatUI(ui_we_want_to_set),
         f"{language_wrapper.language_word_dict.get('tab_menu_chat_ui_tab_name')} "
         f"{ui_we_want_to_set.tab_widget.count()}")
 
 
+def add_git_client_tab(ui_we_want_to_set: EditorMain):
+    jeditor_logger.info(f"build_tab_menu.py add git client tab ui_we_want_to_set: {ui_we_want_to_set}")
+    ui_we_want_to_set.tab_widget.addTab(
+        Gitgui(),
+        f"{language_wrapper.language_word_dict.get('tab_menu_git_client_tab_name')} "
+        f"{ui_we_want_to_set.tab_widget.count()}")
+
+def add_git_tree_view_tab(ui_we_want_to_set: EditorMain):
+    jeditor_logger.info(f"build_tab_menu.py add git tree view tab ui_we_want_to_set: {ui_we_want_to_set}")
+    ui_we_want_to_set.tab_widget.addTab(
+        GitTreeViewGUI(),
+        f"{language_wrapper.language_word_dict.get('tab_menu_git_branch_tree_view_tab_name')} "
+        f"{ui_we_want_to_set.tab_widget.count()}")
+
+def add_variable_inspector_tab(ui_we_want_to_set: EditorMain):
+    jeditor_logger.info(f"build_tab_menu.py add variable inspector tab ui_we_want_to_set: {ui_we_want_to_set}")
+    ui_we_want_to_set.tab_widget.addTab(
+        VariableInspector(),
+        f"{language_wrapper.language_word_dict.get('tab_menu_variable_inspector_tab_name')} "
+        f"{ui_we_want_to_set.tab_widget.count()}")
+
+
+def add_console_widget_tab(ui_we_want_to_set: EditorMain):
+    jeditor_logger.info(f"build_tab_menu.py add console widget tab ui_we_want_to_set: {ui_we_want_to_set}")
+    ui_we_want_to_set.tab_widget.addTab(
+        ConsoleWidget(),
+        f"{language_wrapper.language_word_dict.get('tab_menu_console_widget_tab_name')} "
+        f"{ui_we_want_to_set.tab_widget.count()}")