onecoder 0.0.2__py3-none-any.whl

onecoder/tui/app.py

@@ -0,0 +1,263 @@
+"""OneCoder Textual TUI Application."""
+
+import asyncio
+import json
+import httpx
+import os
+from typing import Optional, AsyncGenerator
+
+from textual.app import App, ComposeResult
+from textual.widgets import Header, Footer, Input, RichLog
+from textual.containers import Vertical, Container
+from textual import events
+from textual.binding import Binding
+
+from rich.panel import Panel
+from rich.markdown import Markdown
+
+from ..ipc_auth import get_token_from_ipc
+from .widgets import ChatMessage, ToolCallStatus, ErrorMessage, WelcomeMessage
+from .commands import CommandRegistry
+
+
+class OneCoderApp(App):
+    """Modern Textual TUI for OneCoder agent system."""
+
+    CSS_PATH = "styles.tcss"
+
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "Quit", show=True),
+        Binding("ctrl+l", "clear_log", "Clear Log", show=True),
+        Binding("ctrl+s", "toggle_theme", "Toggle Theme", show=True),
+        Binding("ctrl+d", "toggle_dark", "Dark Mode"),
+    ]
+
+    def __init__(self, api_url: Optional[str] = None):
+        super().__init__()
+        if api_url:
+            self.api_url = api_url
+        else:
+            self.api_url = os.getenv("ONECODER_API_URL", "http://127.0.0.1:8000")
+        self.session_id = "tui-session"
+        self.user_id = "local-user"
+        self.token = None
+        self.is_processing = False
+        self.command_registry = CommandRegistry(self)
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        yield Vertical(
+            RichLog(id="chat-log", markup=True, wrap=True, highlight=True),
+            Input(
+                placeholder="Type your message... (or 'exit' to quit)", id="user-input"
+            ),
+            id="main-container",
+        )
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        self.chat_log = self.query_one("#chat-log", RichLog)
+        self.input_widget = self.query_one("#user-input", Input)
+
+        await self._initialize_session()
+
+        if self.token:
+            self.chat_log.write(WelcomeMessage())
+            self.chat_log.write("\n")
+            self.input_widget.focus()
+
+    async def _initialize_session(self) -> bool:
+        """Initialize TUI and fetch authentication token."""
+        self.chat_log.write(
+            Panel(
+                "[bold blue]OneCoder TUI[/bold blue]",
+                title="Initializing secure session...",
+                border_style="dim",
+            )
+        )
+
+        self.token = await get_token_from_ipc()
+
+        if not self.token:
+            self.chat_log.write(
+                ErrorMessage(
+                    "Could not fetch auth token from IPC.\n"
+                    "Make sure OneCoder server is running: onecoder serve"
+                )
+            )
+            return False
+
+        self.chat_log.write(
+            Panel(
+                "[bold green]✓[/bold green] Session initialized successfully!",
+                title="Success",
+                border_style="bold green",
+            )
+        )
+
+        return True
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle user input submission."""
+        if self.is_processing:
+            return
+
+        message = event.value.strip()
+
+        if not message:
+            return
+
+        # Handle slash commands
+        if message.startswith("/"):
+            self.input_widget.clear()
+            await self.command_registry.handle(message)
+            if message.lower() in ["/quit", "/exit"]:
+                self.exit()
+            return
+
+        if message.lower() in ["exit", "quit"]:
+            self.exit()
+            return
+
+        self.input_widget.disabled = True
+        self.is_processing = True
+
+        await self._process_message(message)
+
+        self.input_widget.disabled = False
+        self.is_processing = False
+        self.input_widget.focus()
+        self.input_widget.clear()
+
+    async def _process_message(self, message: str):
+        """Process user message and stream agent response."""
+        await self._write_user_message(message)
+
+        current_response = ""
+        message_content = []
+
+        async with httpx.AsyncClient(timeout=None) as client:
+            params = {
+                "user_id": self.user_id,
+                "session_id": self.session_id,
+                "message": message,
+                "token": self.token,
+            }
+
+            try:
+                async with client.stream(
+                    "GET", f"{self.api_url}/stream", params=params
+                ) as response:
+                    if response.status_code != 200:
+                        await self._write_error(f"Error: {response.status_code}")
+                        return
+
+                    async for line in response.aiter_lines():
+                        if line.startswith("data: "):
+                            try:
+                                data = json.loads(line[6:])
+
+                                if "text" in data:
+                                    current_response += data["text"]
+                                elif data.get("type") == "Error":
+                                    await self._write_error(
+                                        data.get("message", "Unknown error")
+                                    )
+                                elif "tool_call" in data:
+                                    tool_name = data["tool_call"].get("name", "unknown")
+                                    await self._show_tool_call(
+                                        tool_name, {}, status="running"
+                                    )
+                                elif "tool_result" in data:
+                                    tool_name = data.get("tool_name", "unknown")
+                                    await self._show_tool_call(
+                                        tool_name, {}, status="success"
+                                    )
+
+                            except json.JSONDecodeError:
+                                pass
+
+                if current_response:
+                    await self._write_agent_message(current_response)
+
+            except httpx.ConnectError:
+                await self._write_error(
+                    "Could not connect to OneCoder API.\n"
+                    "Is the server running?\n"
+                    "Run 'onecoder serve' in another terminal."
+                )
+            except Exception as e:
+                await self._write_error(f"Stream Error: {e}")
+
+    async def _write_user_message(self, message: str):
+        """Write user message to chat log."""
+        panel = Panel(message, title="You", border_style="bold green", padding=(0, 1))
+        self.chat_log.write(panel)
+
+    async def _write_agent_message(self, text: str):
+        """Write agent message to chat log with markdown support."""
+        panel = Panel(
+            Markdown(text), title="OneCoder", border_style="bold blue", padding=(0, 1)
+        )
+        self.chat_log.write(panel)
+
+    async def _show_tool_call(
+        self, tool_name: str, tool_args: dict, status: str = "running"
+    ):
+        """Show tool call status in chat log."""
+        if status == "running":
+            content = f"Running [bold]{tool_name}[/bold]..."
+            border_style = "bold yellow"
+        elif status == "success":
+            content = f"[green]✓[/green] [bold]{tool_name}[/bold] finished."
+            border_style = "bold green"
+        else:
+            content = f"[red]✗[/red] [bold]{tool_name}[/bold] failed."
+            border_style = "bold red"
+
+        panel = Panel(
+            content, title="Tool Call", border_style=border_style, padding=(0, 1)
+        )
+        self.chat_log.write(panel)
+
+    async def _write_error(self, message: str):
+        """Write error message to chat log."""
+        panel = Panel(
+            f"Error: {message}",
+            title="Error",
+            border_style="bold red",
+            style="red",
+            padding=(0, 1),
+        )
+        self.chat_log.write(panel)
+
+    async def action_clear_log(self) -> None:
+        """Clear chat log."""
+        self.chat_log.clear()
+
+    async def action_toggle_theme(self) -> None:
+        """Toggle between dark and light theme."""
+        if "light" in self.theme:
+            self.theme = "textual-dark"
+        else:
+            self.theme = "textual-light"
+
+        self.chat_log.write(
+            Panel(
+                f"Theme switched to: {self.theme}",
+                title="Theme",
+                border_style="dim",
+                padding=(0, 1),
+            )
+        )
+
+
+
+def main():
+    """Entry point for running OneCoder TUI."""
+    app = OneCoderApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

onecoder/tui/commands.py

@@ -0,0 +1,150 @@
+from typing import Dict, Any, Callable, Awaitable
+from rich.panel import Panel
+from rich.markdown import Markdown
+from ..evaluation import TTUEvaluator
+
+class CommandRegistry:
+    def __init__(self, app):
+        self.app = app
+        self.commands: Dict[str, Callable] = {}
+        self._register_default_commands()
+
+    def _register_default_commands(self):
+        self.register("help", self.cmd_help, "Show available commands")
+        self.register("clear", self.cmd_clear, "Clear the chat log")
+        self.register("status", self.cmd_status, "Show platform-wide sprint status")
+        self.register("ttu", self.cmd_ttu, "Evaluate Task Technical Understanding (TTU) for current context")
+        self.register("delegate", self.cmd_delegate, "Delegate a task to a local isolated agent. Usage: /delegate <task description>")
+
+    def register(self, name: str, handler: Callable, description: str):
+        self.commands[name] = {"handler": handler, "description": description}
+
+    async def handle(self, command_str: str) -> bool:
+        """
+        Handles a command string (e.g., "/help").
+        Returns True if handled, False if command not found.
+        """
+        parts = command_str.lstrip("/").split()
+        if not parts:
+            return False
+
+        cmd_name = parts[0].lower()
+        args = parts[1:]
+
+        if cmd_name in self.commands:
+            try:
+                await self.commands[cmd_name]["handler"](args)
+            except Exception as e:
+                await self.app._write_error(f"Command error: {str(e)}")
+            return True
+        else:
+            await self.app._write_error(f"Unknown command: /{cmd_name}")
+            return True
+
+    async def cmd_help(self, args):
+        lines = ["[bold]Available Commands:[/bold]"]
+        for name, data in self.commands.items():
+            lines.append(f"• [cyan]/{name}[/cyan]: {data['description']}")
+
+        panel = Panel("\n".join(lines), title="Help", border_style="blue")
+        self.app.chat_log.write(panel)
+
+    async def cmd_clear(self, args):
+        self.app.chat_log.clear()
+
+    async def cmd_status(self, args):
+        # We can implement a simple status check here, possibly calling the same logic as CLI status
+        # For now, let's mock or use basic discovery
+        from pathlib import Path
+        import json
+
+        root_path = Path(".").resolve() # Or configure root
+        sprint_dirs = []
+        for p in root_path.rglob(".sprint"):
+             if "node_modules" in p.parts or ".git" in p.parts:
+                continue
+             sprint_dirs.append(p)
+
+        if not sprint_dirs:
+            self.app.chat_log.write(Panel("No active sprints found.", title="Status", border_style="yellow"))
+            return
+
+        status_lines = []
+        for sd in sprint_dirs:
+            component = sd.parent.name
+            subdirs = sorted([d for d in sd.iterdir() if d.is_dir()])
+            if subdirs:
+                active = subdirs[-1]
+                sprint_json = active / "sprint.json"
+                state_str = "Unknown"
+                if sprint_json.exists():
+                    try:
+                        with open(sprint_json) as f:
+                            data = json.load(f)
+                            state_str = data.get("status", {}).get("state", "unknown")
+                    except:
+                        pass
+                status_lines.append(f"• [bold]{component}[/bold] -> {active.name}: [green]{state_str}[/green]")
+
+        self.app.chat_log.write(Panel("\n".join(status_lines), title="Platform Status", border_style="blue"))
+
+    async def cmd_ttu(self, args):
+        evaluator = TTUEvaluator()
+        result = evaluator.evaluate()
+
+        color = "green" if result.passed else "red"
+        icon = "✓" if result.passed else "✗"
+
+        lines = [
+            f"**Score:** {result.score:.2f} / 1.0",
+            "",
+            "**Context Found:**",
+            *[f"- {c}" for c in result.context_found],
+        ]
+
+        if result.failure_modes:
+            lines.append("")
+            lines.append("**Potential Failure Modes:**")
+            lines.extend([f"- [red]{m}[/red]" for m in result.failure_modes])
+
+        if result.missing_context:
+            lines.append("")
+            lines.append("**Missing Context:**")
+            lines.extend([f"- {c}" for c in result.missing_context])
+
+        if result.recommendations:
+            lines.append("")
+            lines.append("**Recommendations:**")
+            lines.extend([f"- {r}" for r in result.recommendations])
+
+        panel = Panel(
+            Markdown("\n".join(lines)),
+            title=f"{icon} TTU Evaluation",
+            border_style=f"bold {color}"
+        )
+        self.app.chat_log.write(panel)
+    async def cmd_delegate(self, args):
+        if not args:
+            await self.app._write_error("Usage: /delegate <task description>")
+            return
+
+        task_desc = " ".join(args)
+        self.app.chat_log.write(Panel(f"Delegating task: [bold]{task_desc}[/bold]", title="Delegation", border_style="yellow"))
+
+        try:
+            from ..services.delegation_service import DelegationService
+            service = DelegationService()
+            session = service.create_session(task_id=f"delegate-{task_desc[:10]}", command=task_desc)
+            
+            # Start the session (async)
+            connection_info = await service.start_session(session)
+            
+            self.app.chat_log.write(Panel(
+                f"Delegated successfully!\n\n"
+                f"**Backend:** local-tui\n"
+                f"**Worktree:** {session.worktree_path}\n"
+                f"**To Attach:** [cyan]{connection_info}[/cyan]",
+                title="Success", border_style="bold green"
+            ))
+        except Exception as e:
+            await self.app._write_error(f"Delegation failed: {str(e)}")

onecoder/tui/widgets.py

@@ -0,0 +1,92 @@
+"""Custom widgets for OneCoder TUI."""
+
+from textual.widgets import Static, LoadingIndicator
+from rich.panel import Panel
+from rich.markdown import Markdown
+from typing import Optional
+
+
+class ChatMessage(Static):
+    """Widget for displaying chat messages with markdown support."""
+
+    def __init__(self, message: str, role: str = "user", **kwargs):
+        super().__init__(**kwargs)
+        self.message = message
+        self.role = role
+
+    def render(self):
+        if self.role == "user":
+            panel = Panel(
+                self.message, title="You", border_style="bold blue", padding=(0, 1)
+            )
+            return panel
+        else:
+            panel = Panel(
+                Markdown(self.message),
+                title="OneCoder",
+                border_style="bold green",
+                padding=(0, 1),
+            )
+            return panel
+
+
+class ToolCallStatus(Static):
+    """Widget for displaying tool call status."""
+
+    def __init__(self, tool_name: str, status: str = "running", **kwargs):
+        super().__init__(**kwargs)
+        self.tool_name = tool_name
+        self.status = status
+
+    def render(self):
+        if self.status == "running":
+            content = f"Running {self.tool_name}..."
+            border_style = "bold yellow"
+        elif self.status == "success":
+            content = f"✓ {self.tool_name} finished"
+            border_style = "bold green"
+        else:
+            content = f"✗ {self.tool_name} failed"
+            border_style = "bold red"
+
+        panel = Panel(
+            content, title="Tool Call", border_style=border_style, padding=(0, 1)
+        )
+        return panel
+
+
+class ErrorMessage(Static):
+    """Widget for displaying error messages."""
+
+    def __init__(self, message: str, **kwargs):
+        super().__init__(**kwargs)
+        self.message = message
+
+    def render(self):
+        panel = Panel(
+            self.message,
+            title="Error",
+            border_style="bold red",
+            style="red",
+            padding=(0, 1),
+        )
+        return panel
+
+
+class WelcomeMessage(Static):
+    """Widget for displaying welcome message on startup."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def render(self):
+        from rich.text import Text
+        from rich.console import Group
+
+        title = Text("OneCoder TUI", style="bold blue")
+        subtitle = Text(
+            "Modern terminal interface for AI-powered coding assistance", style="dim"
+        )
+
+        panel = Panel(Group(title, "", subtitle), border_style="blue", padding=(1, 2))
+        return panel

onecoder/worktree.py

@@ -0,0 +1,186 @@
+import os
+import subprocess
+import shutil
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+class WorktreeManager:
+    """
+    Manages Git worktrees for isolated task execution.
+    """
+
+    def __init__(self, project_root: Optional[str] = None):
+        if project_root:
+            self.project_root = Path(project_root).absolute()
+        else:
+            self.project_root = self._find_repo_root(Path.cwd())
+            
+        self.worktrees_dir = self.project_root / ".adk" / "worktrees"
+        self.worktrees_dir.mkdir(parents=True, exist_ok=True)
+
+    def get_current_branch(self) -> str:
+        """Returns the name of the current active branch."""
+        return self._run_git(["rev-parse", "--abbrev-ref", "HEAD"])
+
+    def _find_repo_root(self, start_path: Path) -> Path:
+        """Traverses upwards to find the repository root."""
+        curr = start_path
+        while curr != curr.parent:
+            if (curr / ".git").exists() or (curr / ".sprint").exists():
+                return curr
+            curr = curr.parent
+        return start_path
+
+    def _run_git(self, args: List[str], cwd: Optional[Path] = None) -> str:
+        """Helper to run git commands."""
+        command = ["git"] + args
+        result = subprocess.run(
+            command,
+            cwd=str(cwd or self.project_root),
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Git command failed: {' '.join(command)}\nError: {result.stderr}")
+        return result.stdout.strip()
+
+    def create_worktree(self, task_id: str, base_ref: Optional[str] = None) -> Path:
+        """
+        Creates a new git worktree for a task.
+        Defaults to branching off the current HEAD if base_ref is not provided.
+        """
+        if base_ref is None:
+             base_ref = self.get_current_branch()
+             logger.info(f"No base_ref provided, using current branch: {base_ref}")
+
+        task_dir = self.worktrees_dir / task_id
+        if task_dir.exists():
+            logger.warning(f"Worktree directory already exists: {task_dir}")
+            # Try to remove it first if it's stale
+            self.remove_worktree(task_id)
+
+        branch_name = f"task/{task_id}"
+        
+        # Check if branch exists, if so, use it, otherwise create it
+        try:
+            # Check if branch already exists
+            self._run_git(["rev-parse", "--verify", branch_name])
+            logger.info(f"Using existing branch: {branch_name}")
+            self._run_git(["worktree", "add", str(task_dir), branch_name])
+        except RuntimeError:
+            logger.info(f"Creating new worktree and branch: {branch_name} from {base_ref}")
+            self._run_git(["worktree", "add", "-b", branch_name, str(task_dir), base_ref])
+
+        return task_dir
+
+    def remove_worktree(self, task_id: str, delete_branch: bool = False) -> None:
+        """
+        Removes a git worktree.
+        """
+        task_dir = self.worktrees_dir / task_id
+        if not task_dir.exists():
+            logger.warning(f"Worktree directory does not exist: {task_dir}")
+            # Still try to prune just in case
+            self._run_git(["worktree", "prune"])
+            return
+
+        logger.info(f"Removing worktree: {task_dir}")
+        try:
+            self._run_git(["worktree", "remove", "--force", str(task_dir)])
+        except RuntimeError as e:
+            logger.error(f"Failed to remove worktree via git: {e}")
+            # Fallback to manual removal if git remove fails
+            if task_dir.exists():
+                shutil.rmtree(task_dir, ignore_errors=True)
+                self._run_git(["worktree", "prune"])
+
+        if delete_branch:
+            branch_name = f"task/{task_id}"
+            try:
+                self._run_git(["branch", "-D", branch_name])
+            except RuntimeError:
+                pass
+
+    def merge_task_branch(self, task_id: str, target_branch: str) -> bool:
+        """
+        Merges a task branch into a target branch.
+        Uses --no-ff to preserve atomic work history.
+        """
+        branch_name = f"task/{task_id}"
+        logger.info(f"Merging {branch_name} into {target_branch}")
+        
+        try:
+            # 1. Ensure we are on the target branch
+            current = self.get_current_branch()
+            if current != target_branch:
+                self._run_git(["checkout", target_branch])
+            
+            # 2. Perform merge
+            self._run_git(["merge", "--no-ff", "-m", f"chore: merge delegated task {task_id}", branch_name])
+            return True
+        except RuntimeError as e:
+            logger.error(f"Merge failed: {e}")
+            # If we were on target branch, try to abort merge if it's stuck
+            try:
+                self._run_git(["merge", "--abort"])
+            except:
+                pass
+            return False
+
+    def rebase_onto(self, task_id: str, upstream: str) -> bool:
+        """Rebases the task branch onto an upstream branch to ensure compatibility."""
+        branch_name = f"task/{task_id}"
+        logger.info(f"Rebasing {branch_name} onto {upstream}")
+        original_branch = self.get_current_branch()
+        try:
+            # Note: git rebase <upstream> <branch> switches HEAD to <branch>
+            self._run_git(["rebase", upstream, branch_name])
+            return True
+        except RuntimeError as e:
+            logger.error(f"Rebase failed: {e}")
+            try:
+                self._run_git(["rebase", "--abort"])
+            except:
+                pass
+            return False
+        finally:
+            # Always ensure we return to the original branch
+            if self.get_current_branch() != original_branch:
+                self._run_git(["checkout", original_branch])
+
+    def list_worktrees(self) -> List[dict]:
+        """
+        Lists all active worktrees.
+        """
+        output = self._run_git(["worktree", "list", "--porcelain"])
+        worktrees = []
+        current_wt = {}
+        
+        for line in output.split("\n"):
+            if not line:
+                if current_wt:
+                    worktrees.append(current_wt)
+                    current_wt = {}
+                continue
+            
+            parts = line.split(" ", 1)
+            if len(parts) == 2:
+                current_wt[parts[0]] = parts[1]
+                
+        if current_wt:
+            worktrees.append(current_wt)
+            
+        return worktrees
+
+if __name__ == "__main__":
+    # Quick test
+    logging.basicConfig(level=logging.INFO)
+    mgr = WorktreeManager()
+    path = mgr.create_worktree("test-task")
+    print(f"Worktree created at: {path}")
+    mgr.remove_worktree("test-task", delete_branch=True)
+    print("Worktree removed.")