je-editor 0.0.215__py3-none-any.whl → 0.0.217__py3-none-any.whl

je_editor/pyside_ui/git_ui/git_client_gui.py

@@ -0,0 +1,291 @@
+import traceback
+
+from PySide6.QtGui import QTextOption
+from PySide6.QtWidgets import QWidget, QLabel, QPushButton, QComboBox, QHBoxLayout, QListWidget, QPlainTextEdit, \
+    QSizePolicy, QSplitter, QLineEdit, QVBoxLayout, QMessageBox, QFileDialog, QInputDialog
+
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+from je_editor.git_client.git import Worker, GitService
+from je_editor.git_client.github import GitCloneHandler
+
+
+class Gitgui(QWidget):
+
+    def __init__(self):
+        super().__init__()
+        self.git = GitService()
+        self.clone_handler = GitCloneHandler()
+        self.language_wrapper_get = language_wrapper.language_word_dict.get
+        self._init_ui()
+
+    def _init_ui(self):
+        # Top controls
+        self.repo_label = QLabel(self.language_wrapper_get("label_repo_initial"))
+        self.btn_open = QPushButton(self.language_wrapper_get("btn_open_repo"))
+        self.branch_combo = QComboBox()
+        self.btn_checkout = QPushButton(self.language_wrapper_get("btn_switch_branch"))
+        self.btn_pull = QPushButton(self.language_wrapper_get("btn_pull"))
+        self.btn_push = QPushButton(self.language_wrapper_get("btn_push"))
+        self.remote_combo = QComboBox()
+        self.clone_button = QPushButton(self.language_wrapper_get("btn_clone_remote"))
+        self.clone_button.clicked.connect(self._on_clone_remote_repo)
+
+        top = QHBoxLayout()
+        top.addWidget(self.repo_label, 2)
+        top.addWidget(self.btn_open)
+        top.addWidget(QLabel(self.language_wrapper_get("label_remote")))
+        top.addWidget(self.remote_combo)
+        top.addWidget(QLabel(self.language_wrapper_get("label_branch")))
+        top.addWidget(self.branch_combo, 1)
+        top.addWidget(self.btn_checkout)
+        top.addWidget(self.btn_pull)
+        top.addWidget(self.btn_push)
+        top.addWidget(self.clone_button)
+
+        # Left commits list
+        self.commit_list = QListWidget()
+        self.commit_list.setMinimumWidth(380)
+
+        # Right diff viewer
+        self.diff_view = QPlainTextEdit()
+        self.diff_view.setReadOnly(True)
+        self.diff_view.setWordWrapMode(QTextOption.WrapMode.NoWrap)
+        self.diff_view.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
+        self.diff_view.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        mono = self.font()
+        mono.setFamily("Consolas")
+        mono.setPointSize(10)
+        self.diff_view.setFont(mono)
+
+        splitter = QSplitter()
+        splitter.addWidget(self.commit_list)
+        splitter.addWidget(self.diff_view)
+        splitter.setStretchFactor(0, 0)
+        splitter.setStretchFactor(1, 1)
+
+        # Bottom commit box
+        self.msg_edit = QLineEdit()
+        self.msg_edit.setPlaceholderText(self.language_wrapper_get("placeholder_commit_message"))
+        self.btn_stage_all = QPushButton(self.language_wrapper_get("btn_stage_all"))
+        self.btn_commit = QPushButton(self.language_wrapper_get("btn_commit"))
+
+        bottom = QHBoxLayout()
+        bottom.addWidget(QLabel(self.language_wrapper_get("label_message")))
+        bottom.addWidget(self.msg_edit, 1)
+        bottom.addWidget(self.btn_stage_all)
+        bottom.addWidget(self.btn_commit)
+
+        # Layout
+        center_layout = QVBoxLayout()
+        center_layout.addLayout(top)
+        center_layout.addWidget(splitter, 1)
+        center_layout.addLayout(bottom)
+        self.setLayout(center_layout)
+
+        # Events
+        self.btn_open.clicked.connect(self.on_open_repo)
+        self.branch_combo.currentTextChanged.connect(self.on_branch_changed)
+        self.btn_checkout.clicked.connect(self.on_checkout)
+        self.commit_list.itemSelectionChanged.connect(self.on_commit_selected)
+        self.btn_stage_all.clicked.connect(self.on_stage_all)
+        self.btn_commit.clicked.connect(self.on_commit)
+        self.btn_pull.clicked.connect(self.on_pull)
+        self.btn_push.clicked.connect(self.on_push)
+
+        self._update_controls(enabled=False)
+
+    # ------------- UI helpers -------------
+    def _update_controls(self, enabled: bool):
+        for w in [
+            self.branch_combo, self.btn_checkout, self.commit_list,
+            self.btn_stage_all, self.btn_commit, self.btn_pull, self.btn_push, self.remote_combo
+        ]:
+            w.setEnabled(enabled)
+
+    def _error(self, title: str, err: Exception):
+        traceback.print_exc()
+        QMessageBox.critical(self, title, f"{title}\n\n{err}")
+
+    def _info(self, title: str, msg: str):
+        QMessageBox.information(self, title, msg)
+
+    # ------------- Event handlers -------------
+    def on_open_repo(self):
+        path = QFileDialog.getExistingDirectory(self, self.language_wrapper_get("dialog_choose_repo"))
+        if not path:
+            return
+        try:
+            self.git.open_repo(path)
+            self.repo_label.setText(f"Repo: {path}")
+            self._refresh_branches()
+            self._refresh_remotes()
+            self._update_controls(enabled=True)
+            self._load_commits_async()
+        except Exception as e:
+            self._error(self.language_wrapper_get("err_open_repo"), e)
+
+    def _refresh_remotes(self):
+        self.remote_combo.clear()
+        try:
+            remotes = self.git.remotes()
+            self.remote_combo.addItems(remotes if remotes else [self.language_wrapper_get("default_remote")])
+        except Exception:
+            self.remote_combo.addItem(self.language_wrapper_get("default_remote"))
+
+    def _refresh_branches(self):
+        self.branch_combo.blockSignals(True)
+        self.branch_combo.clear()
+        try:
+            branches = self.git.list_branches()
+            self.branch_combo.addItems(branches)
+            cur = self.git.current_branch()
+            idx = self.branch_combo.findText(cur)
+            if idx >= 0:
+                self.branch_combo.setCurrentIndex(idx)
+        except Exception as e:
+            self._error(self.language_wrapper_get("err_load_branches"), e)
+        finally:
+            self.branch_combo.blockSignals(False)
+
+    def on_branch_changed(self, branch: str):
+        if not branch:
+            return
+        self._load_commits_async(branch)
+
+    def _load_commits_async(self, branch: str | None = None):
+        if branch is None:
+            try:
+                branch = self.git.current_branch()
+            except Exception:
+                return
+        self.commit_list.clear()
+        self.diff_view.setPlainText("")
+        self.worker = Worker(self.git.list_commits, branch, 200)
+        self.worker.done.connect(self._on_commits_loaded)
+        self.worker.start()
+
+    def _on_commits_loaded(self, result, error):
+        if error:
+            self._error(self.language_wrapper_get("err_load_commits"), error)
+            return
+        for c in result:
+            self.commit_list.addItem(f"{c['hexsha'][:8]}  {c['date']}  {c['author']}  {c['summary']}")
+        self.commit_list.setProperty("commit_data", result)
+
+    def on_checkout(self):
+        branch = self.branch_combo.currentText()
+        if not branch:
+            return
+
+        def after(res, err):
+            if err:
+                self._error(self.language_wrapper_get("err_checkout"), err)
+            else:
+                self._refresh_branches()
+                self._load_commits_async(branch)
+                self._info(
+                    self.language_wrapper_get("info_checkout_title"),
+                    f"{self.language_wrapper_get("info_checkout_msg")} {branch}"
+                )
+        self.worker = Worker(self.git.checkout, branch)
+        self.worker.done.connect(after)
+        self.worker.start()
+
+    def on_commit_selected(self):
+        items = self.commit_list.selectedIndexes()
+        if not items:
+            return
+        idx = items[0].row()
+        data = self.commit_list.property("commit_data") or []
+        if idx >= len(data):
+            return
+        sha = data[idx]["hexsha"]
+
+        def after(res, err):
+            if err:
+                self._error(self.language_wrapper_get("err_read_diff"), err)
+            else:
+                self.diff_view.setPlainText(res)
+
+        self.worker = Worker(self.git.show_diff_of_commit, sha)
+        self.worker.done.connect(after)
+        self.worker.start()
+
+    def on_stage_all(self):
+        def after(res, err):
+            if err:
+                self._error(self.language_wrapper_get("err_stage"), err)
+            else:
+                self._info(self.language_wrapper_get("info_stage_title"), self.language_wrapper_get("info_stage_msg"))
+
+        self.worker = Worker(self.git.stage_all)
+        self.worker.done.connect(after)
+        self.worker.start()
+
+    def on_commit(self):
+        msg = self.msg_edit.text()
+
+        def after(res, err):
+            if err:
+                self._error(self.language_wrapper_get("err_commit"), err)
+            else:
+                self.msg_edit.clear()
+                self._load_commits_async()
+                self._info(self.language_wrapper_get("info_commit_title"), self.language_wrapper_get("info_commit_msg"))
+
+        self.worker = Worker(self.git.commit, msg)
+        self.worker.done.connect(after)
+        self.worker.start()
+
+    def on_pull(self):
+        remote = self.remote_combo.currentText() or self.language_wrapper_get("default_remote")
+        branch = self.branch_combo.currentText()
+
+        def after(res, err):
+            if err:
+                self._error(self.language_wrapper_get("err_pull"), err)
+            else:
+                self._load_commits_async()
+                self._info(self.language_wrapper_get("info_pull_title"), str(res))
+
+        self.worker = Worker(self.git.pull, remote, branch)
+        self.worker.done.connect(after)
+        self.worker.start()
+
+    def on_push(self):
+        remote = self.remote_combo.currentText() or self.language_wrapper_get("default_remote")
+        branch = self.branch_combo.currentText()
+
+        def after(res, err):
+            if err:
+                self._error(self.language_wrapper_get("err_push"), err)
+            else:
+                self._info(self.language_wrapper_get("info_push_title"), str(res))
+
+        self.worker = Worker(self.git.push, remote, branch)
+        self.worker.done.connect(after)
+        self.worker.start()
+
+    def _on_clone_remote_repo(self):
+        """
+        UI handler for cloning a remote repository.
+        """
+        url, ok = QInputDialog.getText(self,
+                                       self.language_wrapper_get("dialog_clone_title"),
+                                       self.language_wrapper_get("dialog_clone_prompt"))
+        if not ok or not url.strip():
+            return
+
+        local_dir = QFileDialog.getExistingDirectory(self, self.language_wrapper_get("dialog_select_folder"))
+        if not local_dir:
+            return
+
+        try:
+            repo_path = self.clone_handler.clone_repo(url.strip(), local_dir)
+            self.git.open_repo(repo_path)
+            QMessageBox.information(self,
+                                    self.language_wrapper_get("info_clone_success_title"),
+                                    f"{self.language_wrapper_get("info_clone_success_msg")} {repo_path}")
+        except Exception as e:
+            QMessageBox.critical(self, self.language_wrapper_get("err_clone_failed_title"), str(e))
+

je_editor/pyside_ui/git_ui/graph_view.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from PySide6.QtCore import Qt, QRectF, QPointF
+from PySide6.QtGui import QPainter, QPainterPath, QPen, QColor, QBrush, QTransform
+from PySide6.QtWidgets import (
+    QGraphicsView,
+    QGraphicsScene,
+    QGraphicsEllipseItem,
+    QGraphicsPathItem, QGraphicsSimpleTextItem,
+)
+
+from je_editor.git_client.commit_graph import CommitGraph
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+
+# Layout constants
+NODE_RADIUS = 6
+ROW_HEIGHT = 28
+LANE_WIDTH = 22
+LEFT_MARGIN = 220  # space for SHA/message text area on the left
+
+# Colors
+EDGE_COLOR = QColor("#888")
+TEXT_COLOR = QColor("#222")
+BG_COLOR = QColor("#ffffff")
+
+# A small, repeatable lane palette
+LANE_COLORS = [
+    QColor("#4C78A8"),
+    QColor("#F58518"),
+    QColor("#E45756"),
+    QColor("#72B7B2"),
+    QColor("#54A24B"),
+    QColor("#EECA3B"),
+    QColor("#B279A2"),
+    QColor("#FF9DA6"),
+    QColor("#9D755D"),
+    QColor("#BAB0AC"),
+]
+
+
+def lane_color(lane: int) -> QColor:
+    if lane < 0:
+        return QColor("#999")
+    return LANE_COLORS[lane % len(LANE_COLORS)]
+
+
+class CommitGraphView(QGraphicsView):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.language_wrapper_get = language_wrapper.language_word_dict.get
+        self.setBackgroundBrush(QBrush(BG_COLOR))
+        self.setRenderHints(
+            self.renderHints()
+            | QPainter.RenderHint.Antialiasing
+            | QPainter.RenderHint.TextAntialiasing
+        )
+        self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)
+        self.setTransformationAnchor(QGraphicsView.ViewportAnchor.AnchorUnderMouse)
+
+        self._scene = QGraphicsScene(self)
+        self.setScene(self._scene)
+
+        self.graph: Optional[CommitGraph] = None
+        self._padding = 40
+        self._zoom = 1.0
+
+    def set_graph(self, graph: CommitGraph):
+        self.graph = graph
+        self._redraw()
+
+    def _lane_x(self, lane: int) -> float:
+        return lane * LANE_WIDTH + NODE_RADIUS * 2
+
+    def _row_y(self, row: int) -> float:
+        return row * ROW_HEIGHT + NODE_RADIUS * 2
+
+    def _redraw(self):
+        self._scene.clear()
+        if not self.graph or not self.graph.nodes:
+            self._scene.setSceneRect(QRectF(0, 0, 800, 400))
+            return
+
+        edge_pen = QPen(EDGE_COLOR, 2)
+        for row, node in enumerate(self.graph.nodes):
+            if not node.parent_shas:
+                continue
+            x0 = self._lane_x(node.lane_index)
+            y0 = self._row_y(row)
+            for p in node.parent_shas:
+                if p not in self.graph.index:
+                    continue
+                prow = self.graph.index[p]
+                parent_node = self.graph.nodes[prow]
+                x1 = self._lane_x(parent_node.lane_index)
+                y1 = self._row_y(prow)
+                path = QPainterPath(QPointF(x0, y0))
+                ctrl_y = (y0 + y1) / 2.0
+                path.cubicTo(QPointF(x0, ctrl_y), QPointF(x1, ctrl_y), QPointF(x1, y1))
+                edge_item = QGraphicsPathItem(path)
+                edge_item.setPen(edge_pen)
+                self._scene.addItem(edge_item)
+
+        for row, node in enumerate(self.graph.nodes):
+            cx = self._lane_x(node.lane_index)
+            cy = self._row_y(row)
+
+            circle = QGraphicsEllipseItem(
+                QRectF(cx - NODE_RADIUS, cy - NODE_RADIUS, NODE_RADIUS * 2, NODE_RADIUS * 2)
+            )
+            circle.setBrush(QBrush(lane_color(node.lane_index)))
+            circle.setPen(QPen(Qt.PenStyle.NoPen))
+            circle.setToolTip(self.language_wrapper_get(
+                "git_graph_tooltip_commit"
+            ).format(short=node.commit_sha[:7],
+                     author=node.author_name,
+                     date=node.commit_date,
+                     msg=node.commit_message))
+            self._scene.addItem(circle)
+
+            label_item = QGraphicsSimpleTextItem(str(row + 1))
+            label_item.setBrush(QBrush(TEXT_COLOR))
+            label_item.setPos(-30, cy - NODE_RADIUS * 2)
+            self._scene.addItem(label_item)
+
+        self._scene.setSceneRect(
+            QRectF(-40, 0,
+                   self._lane_x(max(n.lane_index for n in self.graph.nodes) + 1) + self._padding,
+                   self._row_y(len(self.graph.nodes)) + self._padding)
+        )
+
+    def _apply_initial_view(self):
+        # Start with a mild zoom to fit rows comfortably
+        self._zoom = 0.9
+        self._apply_zoom_transform()
+
+    # Zoom and interaction
+    def wheelEvent(self, event):
+        if not self._scene.items():
+            return
+
+        # Ctrl+Wheel to zoom, else scroll normally
+        if event.modifiers() & Qt.KeyboardModifier.ControlModifier:
+            angle = event.angleDelta().y()
+            factor = 1.0 + (0.1 if angle > 0 else -0.1)
+            self._zoom = max(0.1, min(3.0, self._zoom * factor))
+            self._apply_zoom_transform()
+            event.accept()
+        else:
+            super().wheelEvent(event)
+
+    def _apply_zoom_transform(self):
+        t = QTransform()
+        t.scale(self._zoom, self._zoom)
+        self.setTransform(t)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        # Keep scene rect; do not auto-fit. Users control zoom.
+        # Nothing else needed here.
+
+    # Optional helpers for external controllers
+    def focus_row(self, row: int):
+        """
+        Center the view around a specific row.
+        """
+        if not self.graph or row < 0 or row >= len(self.graph.nodes):
+            return
+        y = self._row_y(row)
+        rect = QRectF(0, y - ROW_HEIGHT * 2, self._scene.width(), ROW_HEIGHT * 4)
+        self.fitInView(rect, Qt.AspectRatioMode.KeepAspectRatio)
+        # Restore user zoom preference after focusing
+        self._apply_zoom_transform()

je_editor/pyside_ui/main_ui/ai_widget/ai_config.py

@@ -0,0 +1,19 @@
+from queue import Queue
+
+
+class AIConfig(object):
+
+    def __init__(self):
+        self.current_ai_model_system_prompt: str = ""
+        self.choosable_ai: dict[str, dict[str, str]] = {
+            "AI_model": {
+                "ai_base_url": "",
+                "ai_api_key": "",
+                "chat_model": "",
+                "prompt_template": "",
+            }
+        }
+        self.message_queue = Queue()
+
+
+ai_config = AIConfig()

je_editor/pyside_ui/main_ui/ai_widget/ask_thread.py

@@ -0,0 +1,17 @@
+from threading import Thread
+
+from je_editor.pyside_ui.main_ui.ai_widget.ai_config import ai_config
+from je_editor.pyside_ui.main_ui.ai_widget.langchain_interface import LangChainInterface
+
+
+class AskThread(Thread):
+
+    def __init__(self, lang_chain_interface: LangChainInterface, prompt):
+        super().__init__()
+        self.lang_chain_interface = lang_chain_interface
+        self.prompt = prompt
+
+
+    def run(self):
+        ai_response = self.lang_chain_interface.call_ai_model(prompt=self.prompt)
+        ai_config.message_queue.put(ai_response)

je_editor/pyside_ui/main_ui/ai_widget/chat_ui.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Union
+
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QFontDatabase
+from PySide6.QtWidgets import QWidget, QPlainTextEdit, QScrollArea, QLabel, QComboBox, QGridLayout, QPushButton, \
+    QMessageBox, QSizePolicy, QLineEdit
+
+from je_editor.pyside_ui.dialog.ai_dialog.set_ai_dialog import SetAIDialog
+from je_editor.pyside_ui.main_ui.ai_widget.ai_config import AIConfig, ai_config
+from je_editor.pyside_ui.main_ui.ai_widget.ask_thread import AskThread
+from je_editor.pyside_ui.main_ui.ai_widget.langchain_interface import LangChainInterface
+from je_editor.utils.json.json_file import read_json
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+
+if TYPE_CHECKING:
+    from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+
+
+class ChatUI(QWidget):
+
+    def __init__(self, main_window: EditorMain):
+        super().__init__()
+        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        self.main_window = main_window
+        # Chat panel
+        self.chat_panel = QPlainTextEdit()
+        self.chat_panel.setLineWrapMode(self.chat_panel.LineWrapMode.NoWrap)
+        self.chat_panel.setReadOnly(True)
+        self.chat_panel_scroll_area = QScrollArea()
+        self.chat_panel_scroll_area.setWidgetResizable(True)
+        self.chat_panel_scroll_area.setViewportMargins(0, 0, 0, 0)
+        self.chat_panel_scroll_area.setWidget(self.chat_panel)
+        self.chat_panel.setFont(QFontDatabase.font(self.font().family(), "", 16))
+        # Prompt input
+        self.prompt_input = QLineEdit()
+        self.prompt_input.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+        self.prompt_input.returnPressed.connect(self.call_ai_model)
+        # Font size combobox
+        self.font_size_label = QLabel(language_wrapper.language_word_dict.get("font_size"))
+        self.font_size_combobox = QComboBox()
+        for font_size in range(2, 101, 2):
+            self.font_size_combobox.addItem(str(font_size))
+        self.font_size_combobox.setCurrentText("16")
+        self.font_size_combobox.currentTextChanged.connect(self.update_panel_text_size)
+        # Buttons
+        self.set_ai_config_button = QPushButton(language_wrapper.language_word_dict.get("chat_ui_set_ai_button"))
+        self.set_ai_config_button.clicked.connect(self.set_ai_config)
+        self.load_ai_config_button = QPushButton(language_wrapper.language_word_dict.get("chat_ui_load_ai_button"))
+        self.load_ai_config_button.clicked.connect(lambda: self.load_ai_config(show_load_complete=True))
+        self.call_ai_model_button = QPushButton(language_wrapper.language_word_dict.get("chat_ui_call_ai_model_button"))
+        self.call_ai_model_button.clicked.connect(self.call_ai_model)
+        # Add to layout
+        self.grid_layout = QGridLayout()
+        self.grid_layout.addWidget(self.chat_panel_scroll_area, 0, 0, 1, 4)
+        self.grid_layout.addWidget(self.call_ai_model_button, 1, 0)
+        self.grid_layout.addWidget(self.font_size_combobox, 1, 1)
+        self.grid_layout.addWidget(self.set_ai_config_button, 1, 2)
+        self.grid_layout.addWidget(self.load_ai_config_button, 1, 3)
+        self.grid_layout.addWidget(self.prompt_input, 2, 0, 1, 4)
+
+        # Variable
+        self.ai_config: AIConfig = ai_config
+        self.lang_chain_interface: Union[LangChainInterface, None] = None
+        self.set_ai_config_dialog = None
+        # Timer to pop queue
+        self.pull_message_timer = QTimer(self)
+        self.pull_message_timer.setInterval(1000)
+        self.pull_message_timer.timeout.connect(self.pull_message)
+        self.pull_message_timer.start()
+
+        # Set layout
+        self.setLayout(self.grid_layout)
+
+        self.load_ai_config()
+
+    def update_panel_text_size(self):
+        self.chat_panel.setFont(
+            QFontDatabase.font(self.font().family(), "", int(self.font_size_combobox.currentText())))
+
+    def load_ai_config(self, show_load_complete: bool = False):
+        ai_config_file = Path(str(Path.cwd()) + "/" + ".jeditor/ai_config.json")
+        if ai_config_file.exists():
+            with open(ai_config_file, "r", encoding="utf-8"):
+                json_data: dict = read_json(str(ai_config_file))
+            if json_data:
+                if json_data.get("AI_model") and len(json_data.get("AI_model")) == 4:
+                    ai_info: dict = json_data.get("AI_model")
+                    if ai_info.get("ai_base_url") and ai_info.get("chat_model"):
+                        ai_config.choosable_ai.update(json_data)
+                    self.lang_chain_interface = LangChainInterface(
+                        main_window=self,
+                        api_key=ai_info.get("ai_api_key"),
+                        base_url=ai_info.get("ai_base_url"),
+                        chat_model=ai_info.get("chat_model"),
+                        prompt_template=ai_info.get("prompt_template"),
+                    )
+            if show_load_complete:
+                load_complete = QMessageBox(self)
+                load_complete.setWindowTitle(language_wrapper.language_word_dict.get("load_ai_messagebox_title"))
+                load_complete.setText(language_wrapper.language_word_dict.get("load_ai_messagebox_text"))
+                load_complete.exec()
+
+
+    def call_ai_model(self):
+        if isinstance(self.lang_chain_interface, LangChainInterface):
+            thread = AskThread(lang_chain_interface=self.lang_chain_interface, prompt=self.prompt_input.text())
+            thread.start()
+        else:
+            ai_info = ai_config.choosable_ai.get('AI_model')
+            QMessageBox.warning(self,
+                                language_wrapper.language_word_dict.get("call_ai_model_error_title"),
+                                language_wrapper.language_word_dict.get(
+                                    f"ai_api_key: {ai_info.get('ai_api_key')}, \n"
+                                    f"ai_base_url: {ai_info.get('ai_base_url')}, \n"
+                                    f"chat_model: {ai_info.get('chat_model')}, \n"
+                                    f"prompt_template: {ai_info.get('prompt_template')}"))
+
+    def pull_message(self):
+        if not ai_config.message_queue.empty():
+            ai_response = ai_config.message_queue.get_nowait()
+            self.chat_panel.appendPlainText(ai_response)
+            self.chat_panel.appendPlainText("\n")
+
+    def set_ai_config(self):
+        # Set and output AI a config file
+        self.set_ai_config_dialog = SetAIDialog()
+        self.set_ai_config_dialog.show()

je_editor/pyside_ui/main_ui/ai_widget/langchain_interface.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import os
+import re
+from typing import Union, TYPE_CHECKING
+
+from PySide6.QtWidgets import QMessageBox
+from langchain.prompts.chat import SystemMessagePromptTemplate
+from langchain_openai import ChatOpenAI
+from pydantic import SecretStr
+
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+
+if TYPE_CHECKING:
+    from je_editor.pyside_ui.main_ui.ai_widget.chat_ui import ChatUI
+
+class LangChainInterface(object):
+
+    def __init__(self, main_window: ChatUI, prompt_template: str, base_url: str, api_key: Union[SecretStr, str],
+                 chat_model: str):
+        self.system_message_prompt = SystemMessagePromptTemplate.from_template(prompt_template)
+        self.base_url = base_url
+        self.api_key = api_key
+        self.chat_model = chat_model
+        self.main_window = main_window
+        os.environ["OPENAI_BASE_URL"] = self.base_url
+        os.environ["OPENAI_API_KEY"] = self.api_key
+        os.environ["CHAT_MODEL"] = self.chat_model
+        self.chat_ai = ChatOpenAI(base_url=self.base_url, api_key=self.api_key, model=self.chat_model)
+
+    def call_ai_model(self, prompt: str) -> str | None:
+        message = None
+        try:
+            message = self.chat_ai.invoke(prompt).text()
+            match = re.search(r"</think>\s*(.*)", message, re.DOTALL)
+            if match:
+                message = match.group(1).strip()
+            else:
+                message = message
+
+        except Exception as error:
+            QMessageBox.warning(self.main_window,
+                                language_wrapper.language_word_dict.get("call_ai_model_error_title"),
+                                str(error))
+        return message

je_editor/pyside_ui/main_ui/main_editor.py

@@ -7,7 +7,7 @@ from typing import Dict, Type
 import jedi.settings
 from PySide6.QtCore import QTimer, QEvent
 from PySide6.QtGui import QFontDatabase, QIcon, Qt, QTextCharFormat
-from PySide6.QtWidgets import QMainWindow, QWidget, QTabWidget, QMessageBox
+from PySide6.QtWidgets import QMainWindow, QWidget, QTabWidget
 from frontengine import FrontEngineMainUI
 from qt_material import QtStyleTools