termuxcode 0.2.0__py3-none-any.whl

termuxcode/__init__.py

@@ -0,0 +1,7 @@
+"""TermuxCode - Python project for Termux development."""
+
+__version__ = "0.2.0"
+
+from .tui import ClaudeChat
+
+__all__ = ['ClaudeChat']

termuxcode/cli.py

@@ -0,0 +1,12 @@
+"""CLI para ejecutar la TUI de termuxcode"""
+from .tui.app import ClaudeChat
+
+
+def main() -> None:
+    """Ejecutar la TUI de termuxcode"""
+    app = ClaudeChat()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

termuxcode/tui/__init__.py

@@ -0,0 +1,6 @@
+"""TUI para Claude Agent SDK - Chat Interface"""
+
+from .app import ClaudeChat
+from .history import MessageHistory
+
+__all__ = ['ClaudeChat', 'MessageHistory']

termuxcode/tui/agent.py

@@ -0,0 +1,96 @@
+"""Módulo para comunicarse con el agente Claude con historial en JSONL"""
+import os
+from typing import TYPE_CHECKING
+
+from claude_agent_sdk import query, ClaudeAgentOptions
+
+from .history import MessageHistory
+
+if TYPE_CHECKING:
+    from .chat import ChatLog
+
+
+class AgentClient:
+    """Cliente para comunicarse con Claude Agent SDK con historial en JSONL"""
+
+    def __init__(
+        self,
+        chat_log: 'ChatLog',
+        history: MessageHistory,
+        cwd: str = None,
+    ):
+        self.chat_log = chat_log
+        self.history = history
+        self.cwd = cwd or os.getcwd()
+
+    async def query(self, prompt: str) -> None:
+        """Ejecutar query del agente con historial en JSONL"""
+
+        # Mostrar mensaje del usuario en la UI
+        self.chat_log.write_user(prompt)
+
+        # Cargar historial (ya está truncado a max_messages por save())
+        history = self.history.load()
+
+        # Construir prompt con el historial y el nuevo mensaje
+        full_prompt = self.history.build_prompt(history, prompt)
+
+        # Usar query() del SDK
+        options = ClaudeAgentOptions(
+            permission_mode="bypassPermissions",
+            cwd=self.cwd,
+            include_partial_messages=False,
+            cli_path="/data/data/com.termux/files/home/.claude/local/claude",
+            max_budget_usd=0.10,
+        )
+
+        old_claudecode = os.environ.pop('CLAUDECODE', None)
+        assistant_response = ""
+
+        try:
+            async for message in query(prompt=full_prompt, options=options):
+                await self._process_message(message)
+                # Acumular la respuesta del asistente
+                if hasattr(message, 'content') and isinstance(message.content, list):
+                    for block in message.content:
+                        if block.__class__.__name__ == "TextBlock":
+                            assistant_response += block.text
+        finally:
+            if old_claudecode:
+                os.environ['CLAUDECODE'] = old_claudecode
+
+        # Guardar mensaje del usuario y respuesta del asistente en historial
+        self.history.append("user", prompt)
+        if assistant_response:
+            self.history.append("assistant", assistant_response)
+
+    async def _process_message(self, message) -> None:
+        """Procesar mensaje del agente"""
+        msg_type = message.__class__.__name__
+
+        if msg_type == "ResultMessage":
+            return
+        elif msg_type == "AssistantMessage":
+            await self._process_assistant(message)
+        elif msg_type == "UserMessage":
+            await self._process_user(message)
+
+    async def _process_assistant(self, message) -> None:
+        """Procesar AssistantMessage"""
+        if hasattr(message, 'content') and isinstance(message.content, list):
+            for block in message.content:
+                block_type = block.__class__.__name__
+
+                if block_type == "TextBlock":
+                    self.chat_log.write_assistant(block.text)
+
+                elif block_type == "ToolUseBlock":
+                    tool_input = str(block.input) if hasattr(block, 'input') else None
+                    self.chat_log.write_tool(block.name, tool_input)
+
+    async def _process_user(self, message) -> None:
+        """Procesar UserMessage (tool results)"""
+        if hasattr(message, 'content') and isinstance(message.content, list):
+            for block in message.content:
+                if block.__class__.__name__ == "ToolResultBlock":
+                    self.chat_log.write_result(str(block.content))

termuxcode/tui/app.py

@@ -0,0 +1,176 @@
+"""App principal - TUI responsive para Claude Agent SDK"""
+from pathlib import Path
+from textual.app import App, ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.widgets import Header, Input, Tabs, Tab
+
+from .chat import ChatLog
+from .agent import AgentClient
+from .history import MessageHistory
+from .sessions import SessionManager
+from .styles import CSS
+
+
+class ClaudeChat(App):
+    """TUI responsive para chat con Claude Agent SDK"""
+
+    CSS = CSS
+    TITLE = "Claude Chat"
+    AUTO_FOCUS = "#message-input"
+
+    BINDINGS = [
+        ("ctrl+n", "new_session", "Nueva sesión"),
+        ("ctrl+w", "close_session", "Cerrar sesión"),
+    ]
+
+    def __init__(self, cwd: str = None, max_history: int = 100):
+        super().__init__()
+        self.cwd = cwd or str(Path.cwd())
+        self.max_history = max_history
+        self.session_manager = SessionManager(Path(self.cwd) / ".sessions")
+        self._current_session_id: str | None = None
+        self._sessions: dict[str, MessageHistory] = {}
+        self.history: MessageHistory | None = None
+        self.agent: AgentClient | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Header(id="header")
+        with VerticalScroll(id="chat-container"):
+            yield ChatLog(id="messages")
+        with Vertical(id="bottom-container"):
+            yield Tabs(id="sessions-tabs")
+            with Vertical(id="input-container"):
+                yield Input(id="message-input", placeholder="Escribe tu mensaje...")
+
+    def on_mount(self) -> None:
+        self.chat_log = self.query_one("#messages", ChatLog)
+        self.tabs = self.query_one("#sessions-tabs", Tabs)
+        self.input = self.query_one("#message-input", Input)
+        self.query_one("#chat-container").anchor()  # Auto-scroll al final
+        self.call_later(self._load_first_session)  # Cargar sesión inicial
+
+    async def _load_first_session(self) -> None:
+        """Cargar sesiones existentes o crear la primera al iniciar la app"""
+        sessions = self.session_manager.list_sessions()
+        if not sessions:
+            session = self.session_manager.create_session("Nueva sesión")
+        else:
+            last_id = self.session_manager.get_last_active()
+            session = self.session_manager.get_session(last_id) or sessions[0]
+
+        await self._switch_to_session(session.id)
+
+    async def _load_history(self) -> None:
+        """Cargar y mostrar el historial de mensajes"""
+        history = self.history.load()
+        for msg in history:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            if role == "user":
+                self.chat_log.write_user(content)
+            elif role == "assistant":
+                self.chat_log.write_assistant(content)
+
+    async def _switch_to_session(self, session_id: str) -> None:
+        """Cambiar a una sesión específica"""
+        session = self.session_manager.get_session(session_id)
+        if not session:
+            return
+
+        self._current_session_id = session_id
+
+        # Obtener o crear MessageHistory para esta sesión
+        if session_id not in self._sessions:
+            self._sessions[session_id] = MessageHistory(
+                filename="messages.jsonl",
+                max_messages=self.max_history,
+                session_id=session_id,
+                cwd=self.cwd
+            )
+
+        self.history = self._sessions[session_id]
+        self.agent = AgentClient(self.chat_log, self.history, self.cwd)
+
+        # Actualizar tabs
+        self._update_tabs()
+
+        # Guardar última sesión activa
+        self.session_manager.set_last_active(session_id)
+
+        # Recargar historial en ChatLog
+        self.chat_log.clear()
+        await self._load_history()
+
+    def _update_tabs(self) -> None:
+        """Actualizar los tabs basado en sesiones existentes"""
+        self.tabs.clear()
+
+        for session in self.session_manager.list_sessions():
+            tab_id = f"tab-{session.id}"
+            self.tabs.add(Tab(session.name, id=tab_id))
+
+        # Activar tab actual
+        if self._current_session_id:
+            for tab in self.tabs.children:
+                if tab.id == f"tab-{self._current_session_id}":
+                    self.tabs.active_tab = tab
+                    break
+
+    def on_tabs_tab_activated(self, event: Tabs.TabActivated) -> None:
+        """Cambio de sesión al hacer clic o presionar Enter en un tab"""
+        tab_id = event.tab.id
+        if tab_id and tab_id.startswith("tab-"):
+            session_id = tab_id[4:]  # Remover prefijo "tab-"
+            self.call_later(self._run_switch_session, session_id)
+
+    def _run_switch_session(self, session_id: str) -> None:
+        """Wrapper async para cambiar de sesión"""
+        import asyncio
+        asyncio.create_task(self._switch_to_session(session_id))
+
+    def action_new_session(self) -> None:
+        """Crear nueva sesión (Ctrl+N)"""
+        session = self.session_manager.create_session()
+        self.call_later(self._run_switch_session, session.id)
+        self.input.focus()
+
+    def action_close_session(self) -> None:
+        """Cerrar sesión actual (Ctrl+W)"""
+        sessions = self.session_manager.list_sessions()
+        if len(sessions) <= 1:
+            return  # No cerrar la última sesión
+
+        if self._current_session_id:
+            self.session_manager.delete_session(self._current_session_id)
+            del self._sessions[self._current_session_id]
+
+            # Cambiar a la primera sesión disponible
+            sessions = self.session_manager.list_sessions()
+            self.call_later(self._run_switch_session, sessions[0].id)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if not event.value.strip():
+            return
+        prompt = event.value
+        event.input.clear()
+        self.call_later(self._run_query, prompt)
+
+    async def _run_query(self, prompt: str) -> None:
+        """Ejecutar query del agente"""
+        if self.agent is None:
+            self.chat_log.write_error("No session loaded. Please wait...")
+            return
+        await self.agent.query(prompt)
+
+
+if __name__ == "__main__":
+    from pathlib import Path
+    import sys
+
+    project_root = Path(__file__).parent.parent.parent
+    src_path = project_root / "src"
+    if str(src_path) not in sys.path:
+        sys.path.insert(0, str(src_path))
+
+    app = ClaudeChat()
+    app.run()

termuxcode/tui/chat.py

@@ -0,0 +1,54 @@
+"""Widget de chat con auto-scroll, wrapping y markdown"""
+from textual.widgets import RichLog
+from rich.markdown import Markdown
+
+
+class ChatLog(RichLog):
+    """Widget de chat con auto-scroll, word wrapping y markdown"""
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            wrap=True,
+            auto_scroll=True,
+            markup=True,
+            min_width=0,
+            **kwargs
+        )
+
+    def write_user(self, content: str) -> None:
+        """Escribir mensaje del usuario"""
+        self.write(f"[bold cyan]You:[/] {content}\n")
+
+    def write_assistant(self, content: str) -> None:
+        """Escribir mensaje del asistente con soporte markdown"""
+        self.write(f"[bold green]Claude:[/]\n")
+        try:
+            md = Markdown(content)
+            self.write(md)
+        except Exception:
+            self.write(f"{content}\n")
+
+    def write_tool(self, tool_name: str, tool_input: str = None) -> None:
+        """Escribir herramienta usada (max 2 líneas)"""
+        self.write(f"[dim][yellow]🔧 {tool_name}[/yellow][/dim]")
+        if tool_input:
+            lines = str(tool_input).split('\n')[:2]
+            preview = '\n'.join(lines)
+            if len(lines) == 2 or len(tool_input) > len(preview):
+                preview = preview + "..."
+            self.write(f"[dim][sub]{preview}[/sub][/dim]")
+        self.write("")
+
+    def write_result(self, content: str) -> None:
+        """Escribir resultado de herramienta (max 2 líneas)"""
+        self.write(f"[dim][sub]✅ Result:[/sub][/dim]")
+        lines = str(content).split('\n')[:2]
+        preview = '\n'.join(lines)
+        if len(lines) == 2 or len(content) > len(preview):
+            preview = preview + "..."
+        self.write(f"[dim][sub]{preview}[/sub][/dim]")
+        self.write("")
+
+    def write_error(self, error: str) -> None:
+        """Escribir error"""
+        self.write(f"[bold red]❌ Error: {error}[/]\n")

termuxcode/tui/history.py

@@ -0,0 +1,72 @@
+"""Módulo para manejo de historial de conversación en JSONL"""
+import json
+import uuid
+from pathlib import Path
+from typing import Optional
+
+
+class MessageHistory:
+    """Gestiona el historial de mensajes en formato JSONL"""
+
+    def __init__(self, filename: str = "messages.jsonl", max_messages: int = 100,
+                 session_id: str = None, cwd: str = None):
+        self.max_messages = max_messages
+        self.cwd = Path(cwd) if cwd else Path.cwd()
+        self.base_dir = self._get_history_dir()
+        self.session_id = session_id or str(uuid.uuid4())[:8]
+        self.filename = filename.replace(".jsonl", f"_{self.session_id}.jsonl")
+        self._history_file = self.base_dir / self.filename
+
+    def _get_history_dir(self) -> Path:
+        """Retorna el directorio donde se guarda el historial"""
+        sessions_dir = self.cwd / ".sessions"
+        sessions_dir.mkdir(parents=True, exist_ok=True)
+        return sessions_dir
+
+    def load(self) -> list[dict]:
+        """Carga el historial desde el archivo JSONL"""
+        if not self._history_file.exists():
+            return []
+        with open(self._history_file, 'r', encoding='utf-8') as f:
+            return [json.loads(line) for line in f if line.strip()]
+
+    def save(self, messages: list[dict]) -> None:
+        """Guarda el historial en el archivo JSONL (limitado a max_messages)"""
+        messages_to_save = messages[-self.max_messages:]
+        with open(self._history_file, 'w', encoding='utf-8') as f:
+            for msg in messages_to_save:
+                f.write(json.dumps(msg, ensure_ascii=False) + '\n')
+
+    def append(self, role: str, content: str) -> list[dict]:
+        """Agrega un mensaje al historial y lo guarda"""
+        history = self.load()
+        history.append({"role": role, "content": content})
+        self.save(history)
+        return history
+
+    def build_prompt(self, history: list[dict], new_message: str) -> str:
+        """Construye el prompt con el historial de conversación"""
+        prompt = ""
+        for msg in history:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            if role == "user":
+                prompt += f"User: {content}\n\n"
+            elif role == "assistant":
+                prompt += f"Assistant: {content}\n\n"
+        prompt += f"User: {new_message}\n\nAssistant:"
+        return prompt
+
+    def clear(self) -> None:
+        """Limpia el historial"""
+        if self._history_file.exists():
+            self._history_file.unlink()
+
+    def count(self) -> int:
+        """Retorna la cantidad de mensajes en el historial"""
+        return len(self.load())
+
+    @property
+    def filepath(self) -> Path:
+        """Retorna la ruta del archivo de historial"""
+        return self._history_file

termuxcode/tui/sessions.py

@@ -0,0 +1,113 @@
+"""Módulo para gestionar múltiples sesiones de chat"""
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+import json
+import uuid
+
+
+@dataclass
+class Session:
+    """Representa una sesión de chat"""
+    id: str
+    name: str
+    created_at: str
+    history_file: Path
+
+    @classmethod
+    def from_dict(cls, data: dict, sessions_dir: Path) -> "Session":
+        """Crear Session desde dict JSON"""
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            created_at=data["created_at"],
+            history_file=sessions_dir / f"messages_{data['id']}.jsonl"
+        )
+
+    def to_dict(self) -> dict:
+        """Convertir a dict para JSON"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "created_at": self.created_at
+        }
+
+
+class SessionManager:
+    """Gestiona múltiples sesiones de chat"""
+
+    def __init__(self, sessions_dir: Path):
+        self.sessions_dir = sessions_dir
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        self._index_file = sessions_dir / "sessions.json"
+        self._sessions: dict[str, Session] = {}
+        self._load_sessions()
+
+    def _load_sessions(self):
+        """Cargar sesiones desde el archivo de índice"""
+        if self._index_file.exists():
+            data = json.loads(self._index_file.read_text())
+            for s in data:
+                session = Session.from_dict(s, self.sessions_dir)
+                self._sessions[session.id] = session
+
+    def _save_sessions(self):
+        """Guardar sesiones al archivo de índice"""
+        data = [s.to_dict() for s in self._sessions.values()]
+        self._index_file.write_text(json.dumps(data, indent=2))
+
+    def create_session(self, name: str = None) -> Session:
+        """Crear una nueva sesión"""
+        session_id = str(uuid.uuid4())[:8]
+        name = name or f"Session {len(self._sessions) + 1}"
+        session = Session(
+            id=session_id,
+            name=name,
+            created_at=datetime.now().isoformat(),
+            history_file=self.sessions_dir / f"messages_{session_id}.jsonl"
+        )
+        self._sessions[session_id] = session
+        self._save_sessions()
+        return session
+
+    def list_sessions(self) -> list[Session]:
+        """Listar todas las sesiones, ordenadas por fecha descendente"""
+        return sorted(
+            self._sessions.values(),
+            key=lambda s: s.created_at,
+            reverse=True
+        )
+
+    def get_session(self, session_id: str) -> Session | None:
+        """Obtener una sesión por ID"""
+        return self._sessions.get(session_id)
+
+    def rename_session(self, session_id: str, new_name: str) -> bool:
+        """Renombrar una sesión"""
+        if session_id in self._sessions:
+            self._sessions[session_id].name = new_name
+            self._save_sessions()
+            return True
+        return False
+
+    def delete_session(self, session_id: str) -> bool:
+        """Eliminar una sesión y su archivo de historial"""
+        if session_id in self._sessions:
+            session = self._sessions[session_id]
+            if session.history_file.exists():
+                session.history_file.unlink()
+            del self._sessions[session_id]
+            self._save_sessions()
+            return True
+        return False
+
+    def get_last_active(self) -> str | None:
+        """Obtener el ID de la última sesión activa"""
+        last_file = self.sessions_dir / ".last_active"
+        if last_file.exists():
+            return last_file.read_text().strip()
+        return None
+
+    def set_last_active(self, session_id: str) -> None:
+        """Establecer la última sesión activa"""
+        (self.sessions_dir / ".last_active").write_text(session_id)

termuxcode/tui/styles.py

@@ -0,0 +1,71 @@
+"""CSS simple para layout vertical como mother.py"""
+
+CSS = """
+Screen {
+    layout: vertical;
+}
+
+/* Header - altura fija pequeña */
+Header {
+    height: 3;
+}
+
+/* Contenedor del chat - ocupa el espacio restante */
+VerticalScroll#chat-container {
+    height: 1fr;
+    width: 100%;
+}
+
+/* ChatLog */
+ChatLog {
+    height: 100%;
+    width: 100%;
+    background: $surface;
+    color: $foreground;
+    scrollbar-gutter: auto;
+}
+
+/* Bottom container (tabs + input) - altura fija */
+#bottom-container {
+    height: 5;
+    width: 100%;
+    background: $panel;
+    border-top: solid $primary;
+}
+
+/* Tabs */
+Tabs {
+    height: 1;
+    background: $panel;
+    border-bottom: solid $primary 50%;
+}
+
+Tab {
+    padding: 0 2;
+    text-style: bold;
+}
+
+Tab.--active {
+    background: $primary;
+    color: $background;
+}
+
+/* Input container */
+#input-container {
+    height: 3;
+    padding: 1 2;
+}
+
+/* Input */
+#message-input {
+    width: 100%;
+    max-height: 3;
+}
+
+/* Placeholder del input */
+#message-input > .input--placeholder {
+    color: $text 50%;
+    text-style: dim;
+}
+
+"""

termuxcode-0.2.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: termuxcode
+Version: 0.2.0
+Summary: Python project for Termux development
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: claude-agent-sdk==0.1.48
+Requires-Dist: textual==8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: textual-dev==1.8.0; extra == "dev"
+
+# TermuxCode
+
+Python project for Termux development.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Development
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+ruff format .
+
+# Lint code
+ruff check .
+```

termuxcode-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+termuxcode/__init__.py,sha256=2M6qy6RWmUTwXUi0WJ3kb9tzBBR9FChm9nwlXxQ0nrA,136
+termuxcode/cli.py,sha256=eXwO6IXd4OA8joYuy8iWVzRlJQWad_59xZDyk_1IEb0,216
+termuxcode/tui/__init__.py,sha256=En-qENaywC5ONSk8gohasQNAcOuBWPi5yjPzOyBzcCk,158
+termuxcode/tui/agent.py,sha256=4ZUnoml13Cg8O_RXd6opIpUzNPuLtCiv0Ij_iwh21mE,3552
+termuxcode/tui/app.py,sha256=tNKgWCVddqN_BecrAh9m5Rrae0segNwnjiamZSwlwY0,6452
+termuxcode/tui/chat.py,sha256=67l2ZOGoBdbpZ65OkoaMLLKiwH_sdUGnklPi777Ldwo,1936
+termuxcode/tui/history.py,sha256=Bzp_8LrzzpRetcwNn1ghHCjmaR9XmEF4oM8iljPGqqY,2788
+termuxcode/tui/sessions.py,sha256=2c1pHAWKGu9N7lRpWJ6grppylXplhDp3E794eKrBdK4,3800
+termuxcode/tui/styles.py,sha256=eOSK54P24G4OQGPueGiYiJPWT3__PVsY78HZAxyMVPU,1065
+termuxcode-0.2.0.dist-info/METADATA,sha256=OAZwArtZ0AVsaxx07VgeEz22z85VDMJiDAOrIt3TOz4,749
+termuxcode-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+termuxcode-0.2.0.dist-info/entry_points.txt,sha256=UAjoJs1G65ITt11VEKCViHIjxgegpciyHtuc2itUZKI,51
+termuxcode-0.2.0.dist-info/top_level.txt,sha256=__FTqr2MPCx4Yqtn4CceZjid4qLVn7UEQidi8oEHh-E,11
+termuxcode-0.2.0.dist-info/RECORD,,

termuxcode-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

termuxcode-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+termuxcode = termuxcode.cli:main

termuxcode-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+termuxcode