aider-webui 0.1.0__tar.gz

aider_webui-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LX_Aider Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aider_webui-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: aider-webui
+Version: 0.1.0
+Summary: A modern web interface for Aider CLI — split-view Chat UI + Terminal.
+Author: LX_Aider Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/LX-Aider/aider-webui
+Project-URL: Repository, https://github.com/LX-Aider/aider-webui
+Keywords: aider,webui,ai,coding,assistant,terminal
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nicegui>=3.8.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pywinpty>=2.0.0; sys_platform == "win32"
+Dynamic: license-file
+
+# Aider WebUI
+
+A modern web interface for [Aider CLI](https://aider.chat) — split-view **Chat UI** + **Terminal**.
+
+## Features
+
+- 💬 **Chat History** — Clean Markdown rendering of AI conversations
+- ⬛ **Full Terminal** — Real xterm.js terminal with ANSI color support
+- 🔀 **Split View** — Resizable panels for chat and terminal side-by-side
+- 🔒 **State Sync** — Input locks while Aider is processing
+- 📁 **File Picker** — Tree-based file browser for `/add`, `/read-only`, `/run` commands
+- 🧩 **Session Isolation** — Each browser tab gets its own PTY process
+
+## Installation
+
+```bash
+pip install aider-webui
+```
+
+## Quick Start
+
+1. Make sure [Aider](https://aider.chat) is installed and accessible in your PATH.
+
+2. Create a `.env` file in your working directory (optional):
+
+   ```env
+   AIDER_COMMAND=aider
+   WORKING_DIR=.
+   ANTHROPIC_API_KEY=sk-...
+   ```
+
+3. Run:
+
+   ```bash
+   aider-webui
+   ```
+
+4. Open `http://localhost:8080` in your browser.
+
+## Usage
+
+```bash
+# Run with default settings
+aider-webui
+
+# Or run as a Python module
+python -m aider_webui
+```
+
+## Requirements
+
+- Python 3.10+
+- [Aider CLI](https://aider.chat) installed and accessible
+
+## License
+
+MIT

aider_webui-0.1.0/README.md

@@ -0,0 +1,57 @@
+# Aider WebUI
+
+A modern web interface for [Aider CLI](https://aider.chat) — split-view **Chat UI** + **Terminal**.
+
+## Features
+
+- 💬 **Chat History** — Clean Markdown rendering of AI conversations
+- ⬛ **Full Terminal** — Real xterm.js terminal with ANSI color support
+- 🔀 **Split View** — Resizable panels for chat and terminal side-by-side
+- 🔒 **State Sync** — Input locks while Aider is processing
+- 📁 **File Picker** — Tree-based file browser for `/add`, `/read-only`, `/run` commands
+- 🧩 **Session Isolation** — Each browser tab gets its own PTY process
+
+## Installation
+
+```bash
+pip install aider-webui
+```
+
+## Quick Start
+
+1. Make sure [Aider](https://aider.chat) is installed and accessible in your PATH.
+
+2. Create a `.env` file in your working directory (optional):
+
+   ```env
+   AIDER_COMMAND=aider
+   WORKING_DIR=.
+   ANTHROPIC_API_KEY=sk-...
+   ```
+
+3. Run:
+
+   ```bash
+   aider-webui
+   ```
+
+4. Open `http://localhost:8080` in your browser.
+
+## Usage
+
+```bash
+# Run with default settings
+aider-webui
+
+# Or run as a Python module
+python -m aider_webui
+```
+
+## Requirements
+
+- Python 3.10+
+- [Aider CLI](https://aider.chat) installed and accessible
+
+## License
+
+MIT

aider_webui-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68.0", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aider-webui"
+dynamic = ["version"]
+description = "A modern web interface for Aider CLI — split-view Chat UI + Terminal."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "LX_Aider Contributors"},
+]
+keywords = ["aider", "webui", "ai", "coding", "assistant", "terminal"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Web Environment",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: User Interfaces",
+]
+dependencies = [
+    "nicegui>=3.8.0",
+    "python-dotenv>=1.0.0",
+    "pywinpty>=2.0.0; sys_platform == 'win32'",
+]
+
+[project.urls]
+Homepage = "https://github.com/LX-Aider/aider-webui"
+Repository = "https://github.com/LX-Aider/aider-webui"
+
+[project.scripts]
+aider-webui = "aider_webui.main:run"
+
+[tool.setuptools.dynamic]
+version = {attr = "aider_webui.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+aider_webui = ["static/**"]

aider_webui-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aider_webui-0.1.0/src/aider_webui/__init__.py

@@ -0,0 +1,3 @@
+"""Aider WebUI — Web interface for Aider CLI."""
+
+__version__ = "0.1.0"

aider_webui-0.1.0/src/aider_webui/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m aider_webui`."""
+
+from aider_webui.main import run
+
+run()

aider_webui-0.1.0/src/aider_webui/chat_parser.py

@@ -0,0 +1,104 @@
+"""
+Chat history parser.
+Parses Aider's .aider.chat.history.md file into structured messages.
+
+Aider's actual format:
+    #### <user message text>
+
+    <assistant response text>
+
+    > Tokens: ... Cost: ...
+
+Lines starting with '>' are aider system/meta lines (costs, prompts, etc.)
+Lines starting with '# aider chat started' are session markers.
+Lines starting with '####' are user messages.
+Everything else (non-blank, non-meta) after a user message is the assistant response.
+"""
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class ChatMessage:
+    """Represents a single chat message."""
+    role: str       # "user" or "assistant"
+    content: str    # Markdown content
+
+    def __eq__(self, other):
+        if not isinstance(other, ChatMessage):
+            return NotImplemented
+        return self.role == other.role and self.content == other.content
+
+    def __hash__(self):
+        return hash((self.role, self.content))
+
+    def __repr__(self):
+        preview = self.content[:50].replace("\n", "\\n")
+        return f"ChatMessage(role={self.role!r}, content={preview!r}...)"
+
+
+# Matches user prompt lines: #### <message>
+_USER_PROMPT_RE = re.compile(r"^####\s+(.+)$", re.MULTILINE)
+
+# Matches aider meta/system lines (starting with >)
+_META_LINE_RE = re.compile(r"^>\s+", re.MULTILINE)
+
+# Matches session start markers
+_SESSION_RE = re.compile(r"^#\s+aider chat started", re.MULTILINE)
+
+
+def parse_history(text: str) -> list[ChatMessage]:
+    """
+    Parse the full chat history text into a list of ChatMessages.
+
+    Aider writes chat history in this format:
+        #### <user message>
+
+        <assistant response lines>
+
+        > Tokens: ... Cost: ...
+    """
+    messages: list[ChatMessage] = []
+    user_matches = list(_USER_PROMPT_RE.finditer(text))
+
+    for i, match in enumerate(user_matches):
+        # User message is the text after ####
+        user_content = match.group(1).strip()
+        # Skip raw slash-command entries (e.g. "/ask how are you").
+        # Aider writes both the raw command and the processed text;
+        # we only want the processed version.
+        if user_content and not user_content.startswith("/"):
+            messages.append(ChatMessage(role="user", content=user_content))
+
+        # Assistant response is everything between this user prompt
+        # and the next user prompt (or end of text),
+        # excluding meta lines (>) and session markers (#)
+        resp_start = match.end()
+        resp_end = user_matches[i + 1].start() if i + 1 < len(user_matches) else len(text)
+        resp_block = text[resp_start:resp_end]
+
+        # Extract assistant lines: skip blank, meta (>), and session (#) lines
+        assistant_lines = []
+        for line in resp_block.split("\n"):
+            stripped = line.strip()
+            if not stripped:
+                # Keep blank lines within a response block (for formatting)
+                if assistant_lines:
+                    assistant_lines.append("")
+                continue
+            if stripped.startswith(">"):
+                continue
+            if stripped.startswith("# aider chat"):
+                continue
+            assistant_lines.append(line.rstrip())
+
+        # Strip trailing blank lines
+        while assistant_lines and not assistant_lines[-1].strip():
+            assistant_lines.pop()
+
+        assistant_content = "\n".join(assistant_lines).strip()
+        if assistant_content:
+            messages.append(ChatMessage(role="assistant", content=assistant_content))
+
+    return messages

aider_webui-0.1.0/src/aider_webui/chat_poller.py

@@ -0,0 +1,131 @@
+"""
+Chat history file poller.
+Polls .aider.chat.history.md for changes and dispatches new messages.
+"""
+
+import asyncio
+import logging
+import os
+from pathlib import Path
+from typing import Callable, Optional
+
+from .chat_parser import ChatMessage, parse_history
+
+logger = logging.getLogger(__name__)
+
+
+class ChatPoller:
+    """
+    Async task that polls .aider.chat.history.md every 500ms.
+    When new content is detected, parses delta and calls the callback.
+
+    Handles the edge case where Aider truncates and rewrites the file
+    by tracking _last_msg_count instead of relying on content prefix matching.
+    """
+
+    POLL_INTERVAL = 0.5  # seconds
+
+    def __init__(
+        self,
+        history_file: str,
+        on_new_messages: Callable[[list[ChatMessage]], None],
+    ):
+        self._file_path = Path(history_file)
+        self._on_new_messages = on_new_messages
+        self._task: Optional[asyncio.Task] = None
+        self._last_mtime: float = 0
+        self._last_size: int = 0
+        self._last_msg_count: int = 0
+        self._last_messages: list[ChatMessage] = []
+
+    def start(self):
+        """Start the polling asyncio task."""
+        if self._task and not self._task.done():
+            logger.warning("Poller already running")
+            return
+
+        self._task = asyncio.create_task(self._poll_loop())
+        logger.info(f"Chat poller started: {self._file_path}")
+
+    def stop(self):
+        """Stop the polling task."""
+        if self._task and not self._task.done():
+            self._task.cancel()
+            logger.info("Chat poller stopped")
+
+    async def _poll_loop(self):
+        """Main polling loop."""
+        try:
+            while True:
+                await self._check_file()
+                await asyncio.sleep(self.POLL_INTERVAL)
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"Chat poller error: {e}", exc_info=True)
+
+    async def _check_file(self):
+        """Check if the history file has changed.
+
+        Always re-parses the full file and uses index-based tracking
+        to determine truly new messages. This avoids ordering bugs
+        caused by delta-only parsing of partial/growing responses.
+        """
+        if not self._file_path.exists():
+            return
+
+        try:
+            stat = self._file_path.stat()
+            mtime = stat.st_mtime
+            size = stat.st_size
+
+            # Skip if no change
+            if mtime == self._last_mtime and size == self._last_size:
+                return
+
+            self._last_mtime = mtime
+            self._last_size = size
+
+            # Read and parse the FULL file every time
+            content = await asyncio.to_thread(
+                self._file_path.read_text, "utf-8"
+            )
+            all_messages = parse_history(content)
+
+            new_messages: list[ChatMessage] = []
+
+            if len(all_messages) > self._last_msg_count:
+                # New messages were added
+                new_messages = all_messages[self._last_msg_count:]
+            elif len(all_messages) < self._last_msg_count:
+                # File was truncated — reset tracking
+                logger.warning(
+                    f"History file shrank: {self._last_msg_count} → "
+                    f"{len(all_messages)} messages, resetting count"
+                )
+                self._last_msg_count = len(all_messages)
+                self._last_messages = list(all_messages)
+                return
+            elif (
+                all_messages
+                and self._last_messages
+                and all_messages[-1] != self._last_messages[-1]
+            ):
+                # Same count but last message content changed (still growing)
+                # Send as an update so the UI can refresh it in-place
+                new_messages = [all_messages[-1]]
+                # Don't increment _last_msg_count — count hasn't changed
+                self._last_messages = list(all_messages)
+                if new_messages:
+                    self._on_new_messages(new_messages)
+                return
+
+            self._last_msg_count = len(all_messages)
+            self._last_messages = list(all_messages)
+
+            if new_messages:
+                self._on_new_messages(new_messages)
+
+        except Exception as e:
+            logger.error(f"Error reading history file: {e}")
+

aider_webui-0.1.0/src/aider_webui/config_manager.py

@@ -0,0 +1,61 @@
+"""
+Environment configuration manager.
+Loads settings from .env file and provides them to PTY processes.
+"""
+
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+
+class ConfigManager:
+    """Manages environment configuration for Aider CLI sessions."""
+
+    # Keys that will be passed to PTY environment
+    PASSTHROUGH_KEYS = [
+        "ANTHROPIC_API_KEY",
+        "ANTHROPIC_BASE_URL",
+        "OPENAI_API_KEY",
+        "OPENAI_BASE_URL",
+    ]
+
+    def __init__(self, env_file: str = ".env"):
+        self._env_file = Path(env_file)
+        self._config: dict[str, str] = {}
+        self._load()
+
+    def _load(self):
+        """Load configuration from .env file."""
+        if self._env_file.exists():
+            load_dotenv(self._env_file, override=True)
+
+        self._config = {
+            "AIDER_COMMAND": os.getenv("AIDER_COMMAND", "aider"),
+            "WORKING_DIR": os.getenv("WORKING_DIR", "."),
+        }
+
+        # Load API keys / base URLs if set
+        for key in self.PASSTHROUGH_KEYS:
+            value = os.getenv(key)
+            if value:
+                self._config[key] = value
+
+    @property
+    def aider_command(self) -> str:
+        return self._config["AIDER_COMMAND"]
+
+    @property
+    def working_dir(self) -> str:
+        return str(Path(self._config["WORKING_DIR"]).resolve())
+
+    def get_env_dict(self) -> dict[str, str]:
+        """Return environment variables dict to pass to PTY process."""
+        env = os.environ.copy()
+        for key in self.PASSTHROUGH_KEYS:
+            if key in self._config:
+                env[key] = self._config[key]
+        return env
+
+    def reload(self):
+        """Reload configuration from .env file."""
+        self._load()