ai-comm 0.2.4__py3-none-any.whl

ai_comm/__init__.py

@@ -0,0 +1,3 @@
+"""Cross-AI CLI communication tool for kitty terminal."""
+
+__version__ = "0.2.4"

ai_comm/adapters/__init__.py

@@ -0,0 +1,41 @@
+"""AI CLI adapters registry."""
+
+from __future__ import annotations
+
+import importlib
+
+from .base import AIAdapter, ResponseCollector
+from .generic import GenericAdapter
+
+
+def get_adapter(name: str) -> AIAdapter:
+    """Get an adapter instance by name.
+
+    Loads adapter dynamically from registry to avoid duplication.
+    """
+    from ai_comm.registry import CLI_REGISTRY
+
+    info = CLI_REGISTRY.get(name)
+    if info is None:
+        return GenericAdapter()
+
+    module = importlib.import_module(info.adapter_module)
+    class_name = f"{name.capitalize()}Adapter"
+    adapter_class: type[AIAdapter] = getattr(module, class_name)
+    return adapter_class()
+
+
+def list_adapters() -> list[str]:
+    """List available adapter names."""
+    from ai_comm.registry import list_cli_names
+
+    return list_cli_names()
+
+
+__all__ = [
+    "AIAdapter",
+    "GenericAdapter",
+    "ResponseCollector",
+    "get_adapter",
+    "list_adapters",
+]

ai_comm/adapters/aider.py

@@ -0,0 +1,63 @@
+"""Adapter for Aider CLI."""
+
+from __future__ import annotations
+
+import re
+from typing import ClassVar
+
+from ai_comm.parsers.utils import is_separator_line, strip_trailing_empty
+
+from .base import AIAdapter
+
+
+class AiderAdapter(AIAdapter):
+    """Adapter for Aider CLI responses."""
+
+    name: ClassVar[str] = "aider"
+
+    TOKEN_PATTERN = re.compile(r"^Tokens:\s+[\d.]+[kM]?\s+sent")
+
+    def format_message(self, message: str, sender: str | None = None) -> str:
+        """Prepend /ask to prevent automatic file edits."""
+        base_message = super().format_message(message, sender)
+        return "/ask " + base_message
+
+    def extract_last_response(self, text: str) -> str:
+        """Extract the last response from Aider CLI output."""
+        lines = text.split("\n")
+
+        input_end_indices: list[int] = []
+        in_input = False
+
+        for i, line in enumerate(lines):
+            if line.startswith("> ") and line.strip() != ">":
+                in_input = True
+            elif in_input:
+                input_end_indices.append(i)
+                in_input = False
+
+        if not input_end_indices:
+            return ""
+
+        last_input_end = input_end_indices[-1]
+        response_lines: list[str] = []
+
+        for i in range(last_input_end, len(lines)):
+            line = lines[i]
+            stripped = line.strip()
+
+            if not response_lines and not stripped:
+                continue
+
+            if is_separator_line(stripped):
+                break
+            if self.TOKEN_PATTERN.match(stripped):
+                break
+            if stripped == ">":
+                break
+            if line.startswith("> "):
+                break
+
+            response_lines.append(line)
+
+        return self.finalize_response(strip_trailing_empty(response_lines))

ai_comm/adapters/base.py

@@ -0,0 +1,132 @@
+"""Base adapter for AI CLI interactions using composition."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, ClassVar
+
+from ai_comm.parsers.utils import (
+    clean_response_lines,
+    join_response,
+    remove_base_indent,
+)
+
+if TYPE_CHECKING:
+    from ai_comm.kitten_client import KittenClient
+
+
+class AIAdapter(ABC):
+    """Abstract base class for AI CLI adapters.
+
+    Uses composition: wraps a ResponseParser for parsing logic.
+    Adds CLI-specific message formatting and response fetching.
+    """
+
+    name: ClassVar[str] = "base"
+
+    STATUS_INDICATORS: ClassVar[list[str]] = []
+    BASE_INDENT: ClassVar[int] = 0
+
+    def format_message(self, message: str, sender: str | None = None) -> str:
+        """Format outgoing message for this CLI.
+
+        Default: Add sender header if available.
+        Override: e.g., Aider adds /ask prefix.
+        """
+        if sender:
+            header = (
+                f"[ai-comm: Cross-AI Message]\n"
+                f"From: {sender}\n"
+                f"Note: This is NOT user input. Another AI assistant is sending "
+                f"you this message programmatically via the ai-comm tool.\n"
+                f"---\n"
+            )
+            return header + message
+        return message
+
+    def fetch_response(
+        self,
+        client: KittenClient,
+        window_id: int,
+        extent: str = "all",
+    ) -> str:
+        """Fetch and parse response from window.
+
+        Default: Get terminal text and parse.
+        Override: e.g., OpenCode uses export command.
+        """
+        text = client.get_text(window_id, extent)
+        return self.extract_last_response(text)
+
+    @abstractmethod
+    def extract_last_response(self, text: str) -> str:
+        """Extract the last response from terminal output."""
+        raise NotImplementedError
+
+    def is_status_line(self, line: str) -> bool:
+        """Check if line is a status bar line (should be skipped)."""
+        if not self.STATUS_INDICATORS:
+            return False
+        stripped = line.strip()
+        return any(indicator in stripped for indicator in self.STATUS_INDICATORS)
+
+    def strip_indent(self, line: str) -> str:
+        """Remove base indentation from line."""
+        return remove_base_indent(line, self.BASE_INDENT)
+
+    def finalize_response(self, lines: list[str]) -> str:
+        """Clean up and join response lines."""
+        cleaned = clean_response_lines(lines)
+        return join_response(cleaned)
+
+
+class ResponseCollector:
+    """Helper for collecting multi-block responses.
+
+    Common pattern used by most adapters:
+    - Track multiple response blocks
+    - Handle in_response state
+    - Save current block when new one starts or control element found
+    """
+
+    def __init__(self) -> None:
+        self.responses: list[list[str]] = []
+        self.current: list[str] = []
+        self.in_response: bool = False
+
+    def start_new(self, first_line: str | None = None) -> None:
+        """Start a new response block, saving current if exists."""
+        if self.in_response and self.current:
+            self.responses.append(self.current)
+        self.current = []
+        self.in_response = True
+        if first_line is not None:
+            self.current.append(first_line)
+
+    def end_current(self) -> None:
+        """End current response block."""
+        if self.in_response and self.current:
+            self.responses.append(self.current)
+            self.current = []
+        self.in_response = False
+
+    def add_line(self, line: str) -> None:
+        """Add line to current response if collecting."""
+        if self.in_response:
+            self.current.append(line)
+
+    def add_empty(self) -> None:
+        """Add empty line to current response if collecting."""
+        if self.in_response:
+            self.current.append("")
+
+    def finalize(self) -> list[str]:
+        """Get the last response block."""
+        if self.in_response and self.current:
+            self.responses.append(self.current)
+            self.current = []
+            self.in_response = False
+
+        if self.responses:
+            return self.responses[-1]
+        return []

ai_comm/adapters/claude.py

@@ -0,0 +1,72 @@
+"""Adapter for Claude Code CLI."""
+
+from __future__ import annotations
+
+import re
+from typing import ClassVar
+
+from ai_comm.parsers.utils import is_separator_line
+
+from .base import AIAdapter, ResponseCollector
+
+
+class ClaudeAdapter(AIAdapter):
+    """Adapter for Claude Code CLI responses."""
+
+    name: ClassVar[str] = "claude"
+    BASE_INDENT: ClassVar[int] = 2
+    STATUS_INDICATORS: ClassVar[list[str]] = ["tokens", "§", "☉", "$", "◔", "⎇"]
+
+    TOOL_CALL_PATTERN = re.compile(
+        r"^⏺\s*(Read|Write|Edit|Bash|Glob|Grep|Task|WebFetch|WebSearch|"
+        r"TodoWrite|NotebookEdit|AskUserQuestion|KillShell|TaskOutput)\s*\("
+    )
+
+    SPINNER_CHARS = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+    def _is_control_element(self, stripped: str) -> bool:
+        """Check if line is a control element that ends a response."""
+        if stripped.startswith(">"):
+            return True
+        if stripped.startswith("∴"):
+            return True
+        if stripped.startswith("⎿"):
+            return True
+        if stripped.startswith(("╭", "╰")):
+            return True
+        return is_separator_line(stripped)
+
+    def extract_last_response(self, text: str) -> str:
+        """Extract the last response from Claude Code output."""
+        lines = text.split("\n")
+        collector = ResponseCollector()
+
+        for line in lines:
+            stripped = line.strip()
+
+            if self.is_status_line(line):
+                continue
+
+            if stripped and stripped[0] in self.SPINNER_CHARS:
+                continue
+
+            if stripped.startswith("⏺"):
+                if self.TOOL_CALL_PATTERN.match(stripped):
+                    collector.end_current()
+                    continue
+
+                content = stripped[1:].strip()
+                collector.start_new(content if content else None)
+                continue
+
+            if self._is_control_element(stripped):
+                collector.end_current()
+                continue
+
+            if collector.in_response:
+                if not stripped:
+                    collector.add_empty()
+                else:
+                    collector.add_line(self.strip_indent(line))
+
+        return self.finalize_response(collector.finalize())

ai_comm/adapters/codex.py

@@ -0,0 +1,50 @@
+"""Adapter for OpenAI Codex CLI."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from .base import AIAdapter
+
+
+class CodexAdapter(AIAdapter):
+    """Adapter for OpenAI Codex CLI responses."""
+
+    name: ClassVar[str] = "codex"
+    BASE_INDENT: ClassVar[int] = 2
+
+    def extract_last_response(self, text: str) -> str:
+        """Extract the last response block starting with bullet."""
+        lines = text.split("\n")
+
+        response_start_indices = [
+            i for i, line in enumerate(lines) if line.strip().startswith("•")
+        ]
+
+        if not response_start_indices:
+            return ""
+
+        last_start = response_start_indices[-1]
+        response_lines: list[str] = []
+
+        for i in range(last_start, len(lines)):
+            line = lines[i]
+            stripped = line.strip()
+
+            if i == last_start:
+                response_lines.append(stripped[1:].strip())
+            elif line.startswith(" " * self.BASE_INDENT) and not stripped.startswith(
+                "›"
+            ):
+                response_lines.append(self.strip_indent(line))
+            elif stripped.startswith("›"):
+                break
+            elif stripped == "":
+                remaining = lines[i + 1 :] if i + 1 < len(lines) else []
+                next_content = next((ln for ln in remaining if ln.strip()), "")
+                if next_content.strip().startswith("›"):
+                    break
+            else:
+                break
+
+        return self.finalize_response(response_lines)

ai_comm/adapters/cursor.py

@@ -0,0 +1,71 @@
+"""Adapter for Cursor Agent CLI."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from ai_comm.parsers.utils import strip_trailing_empty
+
+from .base import AIAdapter
+
+
+class CursorAdapter(AIAdapter):
+    """Adapter for Cursor Agent CLI responses."""
+
+    name: ClassVar[str] = "cursor"
+    STATUS_INDICATORS: ClassVar[list[str]] = [
+        "Composer",
+        "/ commands",
+        "@ files",
+        "! shell",
+    ]
+
+    def _is_box_end(self, line: str) -> bool:
+        """Check if line is a box end."""
+        stripped = line.strip()
+        return stripped.startswith("└") and "─" in stripped and stripped.endswith("┘")
+
+    def _is_box_start(self, line: str) -> bool:
+        """Check if line is a box start."""
+        stripped = line.strip()
+        return stripped.startswith("┌") and "─" in stripped
+
+    def extract_last_response(self, text: str) -> str:
+        """Extract the last response from Cursor Agent output."""
+        lines = text.split("\n")
+
+        box_ends = [i for i, line in enumerate(lines) if self._is_box_end(line)]
+
+        if not box_ends:
+            return ""
+
+        user_input_end = -1
+        for end_idx in box_ends:
+            is_prompt_box = any(
+                "→" in lines[j] for j in range(max(0, end_idx - 5), end_idx)
+            )
+            if not is_prompt_box:
+                user_input_end = end_idx
+
+        if user_input_end == -1:
+            return ""
+
+        response_lines: list[str] = []
+        in_response = False
+
+        for i in range(user_input_end + 1, len(lines)):
+            line = lines[i]
+            stripped = line.strip()
+
+            if not in_response and not stripped:
+                continue
+
+            if self._is_box_start(line):
+                break
+            if self.is_status_line(line):
+                break
+
+            in_response = True
+            response_lines.append(line)
+
+        return self.finalize_response(strip_trailing_empty(response_lines))

ai_comm/adapters/gemini.py

@@ -0,0 +1,56 @@
+"""Adapter for Gemini CLI."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from .base import AIAdapter, ResponseCollector
+
+
+class GeminiAdapter(AIAdapter):
+    """Adapter for Gemini CLI responses."""
+
+    name: ClassVar[str] = "gemini"
+    BASE_INDENT: ClassVar[int] = 2
+    STATUS_INDICATORS: ClassVar[list[str]] = [
+        "no sandbox",
+        "/model",
+        "Type your message",
+        "accepting edits",
+    ]
+
+    def extract_last_response(self, text: str) -> str:
+        """Extract the last response from Gemini CLI output."""
+        lines = text.split("\n")
+        collector = ResponseCollector()
+
+        for line in lines:
+            stripped = line.strip()
+
+            if not stripped:
+                collector.add_empty()
+                continue
+
+            if self.is_status_line(line):
+                continue
+
+            if not collector.in_response and stripped.startswith(("╭", "╰", "│", "ℹ")):
+                continue
+
+            if collector.in_response and stripped.startswith("╭─"):
+                collector.end_current()
+                continue
+
+            if stripped.startswith("✦"):
+                content = stripped[1:].strip()
+                collector.start_new(content if content else None)
+                continue
+
+            if stripped.startswith(">"):
+                collector.end_current()
+                continue
+
+            if collector.in_response:
+                collector.add_line(self.strip_indent(line))
+
+        return self.finalize_response(collector.finalize())

ai_comm/adapters/generic.py

@@ -0,0 +1,42 @@
+"""Generic adapter using common prompt patterns."""
+
+from __future__ import annotations
+
+import re
+from typing import ClassVar
+
+from .base import AIAdapter
+
+
+class GenericAdapter(AIAdapter):
+    """Generic adapter that tries to extract the last response block."""
+
+    name: ClassVar[str] = "generic"
+
+    PROMPT_PATTERN = re.compile(r"^[>$%›»❯➜]\s*", re.MULTILINE)
+    EMPTY_PROMPT_PATTERN = re.compile(r"^[>$%›»❯➜]\s*$", re.MULTILINE)
+
+    def extract_last_response(self, text: str) -> str:
+        """Extract content after the last prompt-like pattern."""
+        lines = text.strip().split("\n")
+
+        prompt_lines: list[tuple[int, bool]] = []
+        for i, line in enumerate(lines):
+            normalized = line.replace("\u00a0", " ").strip()
+            if self.PROMPT_PATTERN.match(normalized):
+                is_empty = bool(self.EMPTY_PROMPT_PATTERN.fullmatch(normalized))
+                prompt_lines.append((i, is_empty))
+
+        if not prompt_lines:
+            non_empty = [line for line in lines if line.strip()]
+            return self.finalize_response(non_empty[-10:]) if non_empty else ""
+
+        last_idx, last_is_empty = prompt_lines[-1]
+
+        if last_is_empty:
+            if len(prompt_lines) < 2:
+                return self.finalize_response(lines[last_idx + 1 :])
+            second_last_idx = prompt_lines[-2][0]
+            return self.finalize_response(lines[second_last_idx + 1 : last_idx])
+
+        return self.finalize_response(lines[last_idx + 1 :])

ai_comm/adapters/opencode.py

@@ -0,0 +1,151 @@
+"""Adapter for OpenCode CLI."""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+from ai_comm.parsers.utils import clean_response_lines
+
+from .base import AIAdapter, ResponseCollector
+
+if TYPE_CHECKING:
+    from ai_comm.kitten_client import KittenClient
+
+
+class OpenCodeAdapter(AIAdapter):
+    """Adapter for OpenCode CLI responses."""
+
+    name: ClassVar[str] = "opencode"
+    STATUS_INDICATORS: ClassVar[list[str]] = [
+        "OpenCode",
+        "tab switch agent",
+        "ctrl+p commands",
+    ]
+
+    RIGHT_PANEL_MARKERS: ClassVar[list[str]] = [
+        "Greeting",
+        "Context",
+        r"[\d,]+\s*tokens",
+        r"\d+%\s*used",
+        r"\$[\d.]+\s*spent",
+        "LSP",
+        "LSPs will activate",
+    ]
+
+    def fetch_response(
+        self,
+        client: KittenClient,
+        window_id: int,
+        extent: str = "all",
+    ) -> str:
+        """Use OpenCode export command for complete response with fallback."""
+        export_response = self._get_via_export()
+        if export_response:
+            return export_response
+
+        return super().fetch_response(client, window_id, extent)
+
+    def _get_via_export(self) -> str | None:
+        """Get last response via opencode export command."""
+        session_dir = Path.home() / ".local/share/opencode/storage/session/global"
+        if not session_dir.exists():
+            return None
+
+        session_files = sorted(
+            session_dir.glob("ses_*.json"), key=lambda p: p.stat().st_mtime
+        )
+        if not session_files:
+            return None
+
+        session_id = session_files[-1].stem
+
+        try:
+            result = subprocess.run(
+                ["opencode", "export", session_id],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                return None
+
+            output = result.stdout
+            json_start = output.find("{")
+            if json_start == -1:
+                return None
+
+            data = json.loads(output[json_start:])
+            messages = data.get("messages", [])
+
+            for msg in reversed(messages):
+                if msg.get("info", {}).get("role") != "assistant":
+                    continue
+                for part in msg.get("parts", []):
+                    if part.get("type") == "text":
+                        text: str = part.get("text", "")
+                        return text
+
+        except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError):
+            pass
+
+        return None
+
+    def _detect_right_panel_column(self, lines: list[str]) -> int:
+        """Detect the starting column of the right panel."""
+        min_col = float("inf")
+
+        for line in lines:
+            for marker in self.RIGHT_PANEL_MARKERS:
+                match = re.search(marker, line)
+                if match:
+                    col = match.start()
+                    if col > 20 and line[col - 1] == " ":
+                        min_col = min(min_col, col)
+
+        return int(min_col) if min_col != float("inf") else -1
+
+    def _strip_right_panel(self, line: str, panel_col: int) -> str:
+        """Remove right panel by truncating at detected column."""
+        if panel_col > 0 and len(line) > panel_col:
+            return line[:panel_col].rstrip()
+        return line.rstrip()
+
+    def extract_last_response(self, text: str) -> str:
+        """Extract the last response from OpenCode output."""
+        lines = text.split("\n")
+        panel_col = self._detect_right_panel_column(lines)
+        collector = ResponseCollector()
+
+        for line in lines:
+            stripped = line.strip()
+
+            if self.is_status_line(line):
+                continue
+
+            if "╹" in stripped or "▀" in stripped:
+                continue
+
+            if stripped.startswith("▣"):
+                collector.end_current()
+                continue
+
+            if stripped.startswith("┃"):
+                collector.end_current()
+                continue
+
+            if not stripped:
+                collector.add_empty()
+                continue
+
+            if not collector.in_response:
+                collector.start_new()
+            collector.add_line(self._strip_right_panel(line, panel_col))
+
+        result = collector.finalize()
+        cleaned = clean_response_lines(result)
+        return "\n".join(cleaned) if cleaned else ""