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

pyside_ui/git_ui/git_branch_tree_widget.py

@@ -0,0 +1,119 @@
+import logging
+from pathlib import Path
+
+from PySide6.QtCore import QTimer, QFileSystemWatcher, Qt
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import (
+    QFileDialog, QToolBar, QMessageBox, QStatusBar,
+    QSplitter, QWidget, QVBoxLayout
+)
+
+from je_editor.git_client.commit_graph import CommitGraph
+from je_editor.git_client.git_cli import GitCLI
+from je_editor.pyside_ui.git_ui.commit_table import CommitTable
+from je_editor.pyside_ui.git_ui.graph_view import CommitGraphView
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger(__name__)
+
+
+class GitTreeViewGUI(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.language_wrapper_get = language_wrapper.language_word_dict.get
+        self.setWindowTitle(self.language_wrapper_get("git_graph_title"))
+
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+
+        toolbar = QToolBar()
+        act_open = QAction(self.language_wrapper_get("git_graph_toolbar_open"), self)
+        act_open.triggered.connect(self.open_repo)
+        toolbar.addAction(act_open)
+
+        act_refresh = QAction(self.language_wrapper_get("git_graph_toolbar_refresh"), self)
+        act_refresh.triggered.connect(self.refresh_graph)
+        toolbar.addAction(act_refresh)
+
+        main_layout.addWidget(toolbar)
+
+        splitter = QSplitter(Qt.Orientation.Horizontal)
+        self.graph_view = CommitGraphView()
+        self.commit_table = CommitTable()
+        splitter.addWidget(self.graph_view)
+        splitter.addWidget(self.commit_table)
+        splitter.setSizes([600, 400])
+        main_layout.addWidget(splitter, 1)  # 1 表示可伸縮
+
+        self.status = QStatusBar()
+        main_layout.addWidget(self.status)
+
+        self.repo_path = None
+        self.git = None
+
+        self.watcher = QFileSystemWatcher()
+        self.watcher.directoryChanged.connect(self._on_git_changed)
+        self.watcher.fileChanged.connect(self._on_git_changed)
+
+        self.refresh_timer = QTimer()
+        self.refresh_timer.setSingleShot(True)
+        self.refresh_timer.timeout.connect(self.refresh_graph)
+
+        self.commit_table.selectionModel().selectionChanged.connect(self._on_table_selection)
+
+    def _on_table_selection(self, selected, _):
+        if not selected.indexes():
+            return
+        row = selected.indexes()[0].row()
+        self.graph_view.focus_row(row)
+
+    def open_repo(self):
+        path = QFileDialog.getExistingDirectory(self, self.language_wrapper_get("git_graph_menu_open_repo"))
+        if not path:
+            return
+        repo_path = Path(path)
+        git = GitCLI(repo_path)
+        if not git.is_git_repo():
+            QMessageBox.warning(self, self.language_wrapper_get("git_graph_title"),
+                                self.language_wrapper_get("git_graph_error_not_git"))
+            return
+        self.repo_path = repo_path
+        self.git = git
+        self._setup_watcher()
+        self.refresh_graph()
+
+    def _setup_watcher(self):
+        self.watcher.removePaths(self.watcher.files())
+        self.watcher.removePaths(self.watcher.directories())
+        if not self.repo_path:
+            return
+        git_dir = self.repo_path / ".git_client"
+        if git_dir.exists():
+            self.watcher.addPath(str(git_dir))
+            for f in ["HEAD", "packed-refs"]:
+                fp = git_dir / f
+                if fp.exists():
+                    self.watcher.addPath(str(fp))
+            refs_dir = git_dir / "refs"
+            if refs_dir.exists():
+                self.watcher.addPath(str(refs_dir))
+
+    def _on_git_changed(self, path):
+        self.refresh_timer.start(500)
+
+    def refresh_graph(self):
+        if not self.git:
+            return
+        try:
+            refs = self.git.get_all_refs()
+            commits = self.git.get_commits(max_count=500)
+            graph = CommitGraph()
+            graph.build(commits, refs)
+            self.graph_view.set_graph(graph)
+            self.commit_table.set_commits(commits)
+        except Exception as e:
+            QMessageBox.critical(self, self.language_wrapper_get("git_graph_title"),
+                                 f"{self.language_wrapper_get('git_graph_error_exec_failed')}\n{e}")
+

pyside_ui/git_ui/git_client_gui.py

@@ -0,0 +1,292 @@
+import sys
+import traceback
+
+from PySide6.QtGui import QTextOption
+from PySide6.QtWidgets import QWidget, QLabel, QPushButton, QComboBox, QHBoxLayout, QListWidget, QPlainTextEdit, \
+    QSizePolicy, QSplitter, QLineEdit, QVBoxLayout, QMessageBox, QFileDialog, QApplication, 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))
+

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()

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()

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)