srcodex 0.2.0__py3-none-any.whl

srcodex/tui/components/bars/chat_header.py

@@ -0,0 +1,48 @@
+from textual.widgets import Static
+from textual.containers import Horizontal
+from textual.message import Message
+
+
+class ChatHeaderButton(Static):
+    def __init__(self, label: str, button_id: str, **kwargs):
+        super().__init__(label, **kwargs)
+        self.button_id = button_id
+
+
+class ChatHeader(Horizontal):
+    class SettingsClicked(Message):
+        pass
+
+    DEFAULT_CSS = """
+    ChatHeader {
+        height: 1;
+        width: 100%;
+        align: right middle;
+        dock: top;
+    }
+
+    ChatHeaderButton {
+        width: auto;
+        height: 1;
+        background: transparent;
+        padding: 0 1;
+    }
+
+    ChatHeaderButton:hover {
+        background: transparent;
+    }
+
+    ChatHeaderButton#header-settings {
+        margin-right: 4;
+    }
+    """
+
+    def compose(self):
+        yield ChatHeaderButton("✳", "header-chat", id="header-chat")
+        yield ChatHeaderButton("⚙", "header-settings", id="header-settings")
+
+    def on_click(self, event) -> None:
+        clicked = event.widget
+        if isinstance(clicked, ChatHeaderButton):
+            if clicked.button_id == "header-settings":
+                self.post_message(self.SettingsClicked())

srcodex/tui/components/bars/code_tab_bar.py

@@ -0,0 +1,157 @@
+from pathlib import Path
+from textual.widgets import Static
+from textual.containers import Horizontal
+from textual.message import Message
+
+class CloseButton(Static):
+    """Close button for file tab"""
+    def __init__(self, **kwargs):
+        super().__init__("✕", **kwargs)
+
+class FileTab(Horizontal):
+    """File tab with filename and close button"""
+    def __init__(self, file_path: str, active: bool = False, **kwargs):
+        super().__init__(**kwargs)
+        self.file_path = file_path
+        self.filename = Path(file_path).name
+        if active:
+            self.add_class("active")
+
+    def compose(self):
+        yield Static(self.filename, classes="tab-label")
+        yield CloseButton(classes="tab-close")
+
+class CodeTabBar(Horizontal):
+    """Horizonatal tab bar for open files"""
+    class TabClicked(Message):
+        """Posted when file tab is clicked"""
+        def __init__(self, file_path: str):
+            super().__init__()
+            self.file_path = file_path
+
+    class TabClosed(Message):
+        """Posted when tab close button is clicked"""
+        def __init__(self, file_path: str):
+            super().__init__()
+            self.file_path = file_path
+
+    DEFAULT_CSS = """
+    CodeTabBar {
+        height: 1;
+        width: 100%;
+        align: left middle;
+        dock: top;
+    }
+
+    FileTab {
+        width: auto;
+        height: 1;
+        background: transparent;
+        padding: 0 1;
+    }
+
+    FileTab:hover {
+        background: transparent;
+    }
+
+    FileTab.active {
+        text-style: bold;
+    }
+
+    FileTab .tab-label {
+        width: auto;
+        height: 1;
+    }
+
+    FileTab .tab-close {
+        width: auto;
+        height: 1;
+        color: $text-muted;
+        padding: 0 1;
+    }
+
+    FileTab .tab-close:hover {
+        color: $error;
+        text-style: bold;
+    }
+    """
+
+    def __init__(self, **kwargs):
+        self.open_files = [] #list of open files
+        self.active_file = None
+        super().__init__(**kwargs)
+
+    def compose(self):
+        return []
+
+    def add_tab(self, file_path: str, set_active: bool = True):
+        """add new file tab"""
+        if file_path in self.open_files:
+            if set_active:
+                self._set_active_tab(file_path)
+            return
+
+        # add to open files list
+        self.open_files.append(file_path)
+        # create and mount the tab
+        is_active = set_active or len(self.open_files) == 1
+        tab = FileTab(file_path, active=is_active)
+        self.mount(tab)
+
+        if is_active:
+            self.active_file = file_path
+
+    def _set_active_tab(self, file_path: str):
+        """set which tab is active"""
+        self.active_file = file_path
+
+        for tab in self.query(FileTab):
+            if tab.file_path == file_path:
+                tab.add_class("active")
+            else:
+                tab.remove_class("active")
+
+    def close_tab(self, file_path: str):
+        """Close a tab"""
+        if file_path not in self.open_files:
+            return
+
+        self.open_files.remove(file_path)
+
+        # Remove the tab widget
+        for tab in self.query(FileTab):
+            if tab.file_path == file_path:
+                tab.remove()
+                break
+
+        # If this was the active tab, switch to another
+        if self.active_file == file_path:
+            if self.open_files:
+                new_active = self.open_files[-1]
+                self._set_active_tab(new_active)
+                self.post_message(self.TabClicked(new_active))
+            else:
+                self.active_file = None
+
+    def on_click(self, event):
+        """Handle tab clicks and close button"""
+        clicked = event.widget
+
+        # Check if close button was clicked
+        if isinstance(clicked, CloseButton):
+            # Find parent FileTab
+            parent = clicked.parent
+            if isinstance(parent, FileTab):
+                self.close_tab(parent.file_path)
+                self.post_message(self.TabClosed(parent.file_path))
+
+        # Check if tab label or tab itself was clicked
+        elif isinstance(clicked, FileTab):
+            self._set_active_tab(clicked.file_path)
+            self.post_message(self.TabClicked(clicked.file_path))
+
+        # Check if tab label (Static) inside FileTab was clicked
+        elif isinstance(clicked, Static) and isinstance(clicked.parent, FileTab):
+            parent = clicked.parent
+            self._set_active_tab(parent.file_path)
+            self.post_message(self.TabClicked(parent.file_path))

srcodex/tui/components/bars/footer_bar.py

@@ -0,0 +1,128 @@
+from textual.widgets import Static
+from textual.containers import Horizontal
+from pathlib import Path
+import json
+import importlib.metadata
+
+
+class FooterItem(Static):
+    """Individual item in the footer bar"""
+    def __init__(self, label: str, item_id: str, **kwargs):
+        super().__init__(label, **kwargs)
+        self.item_id = item_id
+
+
+class FooterBar(Horizontal):
+    """Footer bar spanning full width at bottom of screen
+
+    Left: version, project name, database name
+    Right: persistent token usage (lifetime stats, never resets)
+    """
+
+    DEFAULT_CSS = """
+    FooterBar {
+        height: 1;
+        width: 100%;
+        align: left middle;
+        dock: bottom;
+    }
+
+    FooterItem {
+        width: auto;
+        height: 1;
+        background: transparent;
+        padding: 0 1;
+    }
+
+    FooterItem:hover {
+        background: transparent;
+    }
+
+    #footer-spacer {
+        width: 1fr;
+    }
+    """
+
+    def __init__(self, project_root: str = None, **kwargs):
+        super().__init__(**kwargs)
+        self.project_root = Path(project_root) if project_root else Path.cwd()
+        self.query_count = 0
+        self.total_user_input = 0
+        self.total_output = 0
+        self.savings_percentage = 0.0
+
+    def compose(self):
+        # Get version from package metadata
+        try:
+            version = importlib.metadata.version("srcodex")
+        except Exception:
+            version = "0.3.0"
+
+        # Get project name and database name from metadata.json
+        metadata_path = self.project_root / ".srcodex" / "metadata.json"
+        project_name = self.project_root.name
+        db_name = "unknown.db"
+
+        try:
+            with open(metadata_path, 'r') as f:
+                metadata = json.load(f)
+                project_name = metadata.get("project", {}).get("name", project_name)
+                db_path = metadata.get("paths", {}).get("database", "")
+                if db_path:
+                    db_name = Path(db_path).name
+        except Exception:
+            pass
+
+        # Load token stats from session
+        self.load_stats()
+
+        # Left side: version, project, database
+        yield FooterItem(f"v{version}", "footer-version", id="footer-version")
+        yield FooterItem(f"🖿 {project_name}", "footer-project", id="footer-project")
+        yield FooterItem(f"☰ {db_name}", "footer-database", id="footer-database")
+
+        # Spacer (pushes token stats to the right)
+        yield FooterItem("", "footer-spacer", id="footer-spacer")
+
+        # Right side: token stats (persistent)
+        yield FooterItem(self._format_stats(), "footer-tokens", id="footer-tokens")
+
+    def load_stats(self):
+        """Load persistent stats from conversation metadata"""
+        metadata_path = self.project_root / ".srcodex" / "conversations" / "latest.json"
+        try:
+            with open(metadata_path, 'r') as f:
+                session_data = json.load(f)
+                metadata = session_data.get("metadata", {})
+                self.query_count = metadata.get("query_count", 0)
+                self.total_user_input = metadata.get("total_user_input", 0)
+                self.total_output = metadata.get("total_output", 0)
+                self.savings_percentage = metadata.get("total_savings_percentage", 0.0)
+        except Exception:
+            pass
+
+    def update_stats(self, query_count, total_user_input, total_output, savings_percentage):
+        """Update footer token stats"""
+        self.query_count = query_count
+        self.total_user_input = total_user_input
+        self.total_output = total_output
+        self.savings_percentage = savings_percentage
+
+        # Update footer display (right side only)
+        footer_item = self.query_one("#footer-tokens", FooterItem)
+        footer_item.update(self._format_stats())
+
+    def _format_stats(self):
+        """Format stats string"""
+        # Format tokens (12500 → 12K, 125000 → 125K)
+        def format_tokens(tokens):
+            if tokens >= 1000:
+                return f"{tokens // 1000}K"
+            return str(tokens)
+
+        return (
+            f"{self.query_count} queries 🪙"
+            f"{format_tokens(self.total_user_input)} input 🪙"
+            f"{format_tokens(self.total_output)} output "
+            f"({self.savings_percentage:.0f}% savings)"
+        )

srcodex/tui/components/bars/left_tab.py

@@ -0,0 +1,54 @@
+from textual.widgets import Static
+from textual.containers import Horizontal
+from textual.message import Message
+
+
+class TabButton(Static):
+    def __init__(self, label: str, tab_id: str, active: bool = False, **kwargs):
+        super().__init__(label, **kwargs)
+        self.tab_id = tab_id
+        if active:
+            self.add_class("active")
+
+
+class LeftTab(Horizontal):
+    class TabClicked(Message):
+        def __init__(self, tab_id: str):
+            super().__init__()
+            self.tab_id = tab_id
+
+    DEFAULT_CSS = """
+    LeftTab {
+        height: 1;
+        width: 100%;
+        align: left middle;
+        dock: top;
+    }
+
+    TabButton {
+        width: auto;
+        height: 1;
+        background: transparent;
+        padding: 0 1;
+    }
+
+    TabButton:hover {
+        background: transparent;
+    }
+
+    TabButton.active {
+        text-style: bold;
+    }
+    """
+
+    def compose(self):
+        yield TabButton("📁", "tab-explorer", active=True, id="tab-explorer")
+        yield TabButton("🔍", "tab-search", id="tab-search")
+
+    def on_click(self, event) -> None:
+        clicked = event.widget
+        if isinstance(clicked, TabButton):
+            for tab in self.query(TabButton):
+                tab.remove_class("active")
+            clicked.add_class("active")
+            self.post_message(self.TabClicked(clicked.tab_id))

srcodex/tui/components/logger.py

@@ -0,0 +1,57 @@
+"""
+TUI Logging Setup
+Logs TUI events to .srcodex/.debug/tui.log
+"""
+import logging
+from pathlib import Path
+import sys
+
+# Add backend to path for config loader
+backend_path = Path(__file__).parent.parent.parent / "backend"
+sys.path.insert(0, str(backend_path))
+
+from services.config_loader import get_config
+
+
+def setup_tui_logging():
+    """
+    Configure TUI logging to write to .srcodex/.debug/tui.log
+    Returns the logger instance
+    """
+    try:
+        config = get_config()
+        debug_dir = config.project_root / ".srcodex" / ".debug"
+        debug_dir.mkdir(parents=True, exist_ok=True)
+
+        log_file = debug_dir / "tui.log"
+
+        # Create logger
+        logger = logging.getLogger('srcodex.tui')
+        logger.setLevel(logging.INFO)
+
+        # File handler (append mode)
+        file_handler = logging.FileHandler(log_file, mode='a')
+        file_handler.setLevel(logging.INFO)
+        file_handler.setFormatter(
+            logging.Formatter('%(asctime)s [%(levelname)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+        )
+
+        logger.addHandler(file_handler)
+        logger.info("=" * 80)
+        logger.info("TUI session started")
+
+        return logger
+
+    except Exception as e:
+        # Fallback logger
+        logger = logging.getLogger('srcodex.tui')
+        logger.setLevel(logging.INFO)
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
+        logger.addHandler(handler)
+        logger.warning(f"Could not set up TUI file logging: {e}")
+        return logger
+
+
+# Initialize logger module-level
+logger = setup_tui_logging()