linkgravity 1.0.0

package/src/messengers/discord_adapter.py

@@ -0,0 +1,240 @@
+"""Discord implementation of MessengerAdapter. All discord.py UI code
+(buttons, modals, embeds) for the main messaging path lives here."""
+
+import asyncio
+from contextlib import asynccontextmanager
+from typing import Any
+
+import discord
+
+from config import logger
+from messengers.base import (
+    MessengerAdapter,
+    PromptHandle,
+    ScopeOption,
+    ToolApprovalOutcome,
+    VoiceCapable,
+)
+
+
+class _DiscordPromptHandle(PromptHandle):
+    def __init__(self, embed: discord.Embed, view: discord.ui.View):
+        self.embed = embed
+        self.view = view
+        self.message: discord.Message | None = None
+        self.outcome: ToolApprovalOutcome | None = None
+
+    async def send(self, conversation_ref: discord.abc.Messageable) -> discord.Message:
+        self.message = await conversation_ref.send(embed=self.embed, view=self.view)
+        return self.message
+
+    async def finalize(self) -> None:
+        for child in self.view.children:
+            child.disabled = True
+        if self.message is None:
+            return
+        try:
+            await self.message.edit(embed=self.embed, view=self.view)
+        except discord.NotFound:
+            pass
+        except discord.HTTPException as e:
+            logger.warning(f"Failed to finalize prompt message: {e}")
+
+
+class DiscordAdapter(MessengerAdapter):
+    platform_name = "discord"
+
+    def __init__(self, bot: discord.Client):
+        self.bot = bot
+
+    # -- plain messaging ---------------------------------------------------
+
+    async def send_message(self, conversation_ref: discord.abc.Messageable, text: str) -> discord.Message:
+        return await conversation_ref.send(text)
+
+    async def edit_message(self, message_ref: discord.Message, text: str) -> bool:
+        try:
+            await message_ref.edit(content=text, embed=None)
+            return True
+        except discord.NotFound:
+            logger.warning("Discord message not found (likely deleted).")
+            return False
+        except discord.Forbidden:
+            logger.error("Forbidden to edit Discord message (missing permissions).")
+            return False
+        except discord.HTTPException as e:
+            logger.warning(f"HTTPException editing Discord message: {e}")
+            return False
+
+    async def send_files(self, conversation_ref: discord.abc.Messageable, file_paths: list[str]) -> None:
+        if not file_paths:
+            return
+        await conversation_ref.send(files=[discord.File(p) for p in file_paths])
+
+    def resolve_conversation(self, conversation_id: str) -> Any:
+        try:
+            return self.bot.get_channel(int(conversation_id))
+        except (TypeError, ValueError):
+            return None
+
+    async def start_conversation(self, origin_ref: discord.Message, title: str) -> discord.Thread:
+        return await origin_ref.create_thread(name=title[:100], auto_archive_duration=1440)
+
+    async def rename_conversation(self, conversation_ref: discord.Thread, title: str) -> None:
+        await conversation_ref.edit(name=title[:100])
+
+    @asynccontextmanager
+    async def typing(self, conversation_ref: discord.abc.Messageable):
+        async with conversation_ref.typing():
+            yield
+
+    # -- interactive prompts ----------------------------------------------
+
+    def create_tool_approval_prompt(
+        self,
+        decision_future: asyncio.Future,
+        title: str,
+        body: str,
+        scope_options: list[ScopeOption],
+    ) -> PromptHandle:
+        embed = discord.Embed(title=title, description=body, color=discord.Color.orange())
+        view = discord.ui.View(timeout=None)
+        handle = _DiscordPromptHandle(embed, view)
+
+        def make_callback(decision: str, scope: ScopeOption | None):
+            async def callback(interaction: discord.Interaction):
+                handle.outcome = ToolApprovalOutcome(decision=decision, scope=scope)
+                if not decision_future.done():
+                    decision_future.set_result(decision)
+
+                for child in view.children:
+                    child.disabled = True
+                if decision == "allow" and scope:
+                    embed.color = discord.Color.green()
+                    embed.title = f"✅ Approved & Auto-Allowed ({scope.scope})"
+                elif decision == "allow":
+                    embed.color = discord.Color.green()
+                    embed.title = "✅ Tool Execution Approved"
+                else:
+                    embed.color = discord.Color.red()
+                    embed.title = "❌ Tool Execution Rejected"
+                await interaction.response.edit_message(embed=embed, view=view)
+
+            return callback
+
+        btn_once = discord.ui.Button(label="✅ Approve once", style=discord.ButtonStyle.green)
+        btn_once.callback = make_callback("allow", None)
+        view.add_item(btn_once)
+
+        for opt in scope_options:
+            suffix = " tool" if opt.kind == "tools" else ""
+            label = f"♾️ Allow [{opt.scope}]{suffix}"
+            if len(label) > 80:
+                label = f"♾️ Allow […{opt.scope[-68:]}]{suffix}"[:80]
+            btn = discord.ui.Button(label=label, style=discord.ButtonStyle.gray)
+            btn.callback = make_callback("allow", opt)
+            view.add_item(btn)
+
+        btn_reject = discord.ui.Button(label="❌ Reject", style=discord.ButtonStyle.red)
+        btn_reject.callback = make_callback("reject", None)
+        view.add_item(btn_reject)
+
+        return handle
+
+    def create_question_prompt(
+        self,
+        answer_future: asyncio.Future,
+        question: str,
+        options: list[str],
+        multi_select: bool = False,
+        allow_write_in: bool = True,
+    ) -> PromptHandle:
+        embed = discord.Embed(
+            title="❓ Question from AI",
+            description=f"**{question}**\n\nPlease select an answer below.",
+            color=discord.Color.blue(),
+        )
+        view = discord.ui.View(timeout=None)
+        handle = _DiscordPromptHandle(embed, view)
+
+        async def _resolve(interaction: discord.Interaction, text: str, note: str):
+            await interaction.response.send_message(f"✅ {note}: **{text}**")
+            if not answer_future.done():
+                answer_future.set_result(text)
+            for child in view.children:
+                child.disabled = True
+            if interaction.message:
+                try:
+                    await interaction.message.edit(view=view)
+                except discord.HTTPException:
+                    pass
+
+        if multi_select and options:
+            select = discord.ui.Select(
+                placeholder="Select multiple options...",
+                min_values=1,
+                max_values=min(len(options), 25),
+                options=[discord.SelectOption(label=opt[:100]) for opt in options[:25]],
+            )
+            view.add_item(select)
+
+            async def submit_callback(interaction: discord.Interaction):
+                if not select.values:
+                    return
+                await _resolve(interaction, ", ".join(select.values), "Selected")
+
+            submit_btn = discord.ui.Button(label="Submit", style=discord.ButtonStyle.primary)
+            submit_btn.callback = submit_callback
+            view.add_item(submit_btn)
+        else:
+            def make_option_callback(opt_text: str):
+                async def callback(interaction: discord.Interaction):
+                    await _resolve(interaction, opt_text, "Selected")
+
+                return callback
+
+            # 25 components per view; leave room for the write-in button.
+            for opt in options[:24]:
+                btn = discord.ui.Button(label=opt[:80], style=discord.ButtonStyle.primary)
+                btn.callback = make_option_callback(opt)
+                view.add_item(btn)
+
+        if allow_write_in:
+            class WriteInModal(discord.ui.Modal, title="Write in"):
+                answer = discord.ui.TextInput(
+                    label="Enter your response",
+                    style=discord.TextStyle.paragraph,
+                    placeholder="Type your response here...",
+                    required=True,
+                    max_length=2000,
+                )
+
+                async def on_submit(modal_self, interaction: discord.Interaction):
+                    await _resolve(interaction, modal_self.answer.value, "Selected (Write in)")
+
+            async def write_in_callback(interaction: discord.Interaction):
+                await interaction.response.send_modal(WriteInModal())
+
+            write_in_btn = discord.ui.Button(label="✍️ Write in", style=discord.ButtonStyle.secondary)
+            write_in_btn.callback = write_in_callback
+            view.add_item(write_in_btn)
+
+        return handle
+
+
+class DiscordVoiceAdapter(DiscordAdapter, VoiceCapable):
+    """Discord adapter with voice wired in. Separate class so it's
+    visible at the type level which code paths need voice."""
+
+    def __init__(self, bot: discord.Client, voice_cog):
+        super().__init__(bot)
+        self.voice_cog = voice_cog
+
+    async def join_voice(self, guild_ref: Any, channel_ref: Any) -> None:
+        raise NotImplementedError("Wire to VoiceCog's /join when migrating voice_cog.py")
+
+    async def leave_voice(self, guild_ref: Any) -> None:
+        raise NotImplementedError("Wire to VoiceCog's /leave when migrating voice_cog.py")
+
+    async def play_tts(self, guild_ref: Any, audio_bytes: bytes) -> None:
+        await self.voice_cog._play_audio(str(guild_ref), audio_bytes)

package/src/messengers/registry.py

@@ -0,0 +1,19 @@
+"""Process-wide messenger adapter instance, set once at startup by
+main.py. Matches the codebase's existing singleton pattern (see
+config.session_manager) so deep call sites don't need the adapter
+threaded through every signature."""
+
+from messengers.base import MessengerAdapter
+
+_adapter: MessengerAdapter | None = None
+
+
+def set_adapter(adapter: MessengerAdapter) -> None:
+    global _adapter
+    _adapter = adapter
+
+
+def get_adapter() -> MessengerAdapter:
+    if _adapter is None:
+        raise RuntimeError("Messenger adapter not initialized - main.py must call set_adapter() at startup.")
+    return _adapter

package/src/services/audio_service.py

@@ -0,0 +1,67 @@
+import asyncio
+import os
+import re
+import tempfile
+from pathlib import Path
+
+from config import TTS_VOICE, bot_settings, logger
+
+
+async def tts(text: str, voice: str = None) -> bytes | None:
+    voice = voice or bot_settings.get("tts_voice", TTS_VOICE)
+    try:
+        import edge_tts
+
+        clean = re.sub(r"[`*#_\[\]()]", "", text)
+        clean = re.sub(r"https?://\S+", "URL", clean)
+        clean = re.sub(r"\n+", ". ", clean).strip()[:800]
+        if not clean:
+            return None
+        hangul_chars = len(re.findall(r"[가-힣]", clean))
+        alpha_chars = len(re.findall(r"[a-zA-Z]", clean))
+        total_letters = hangul_chars + alpha_chars
+        ko_voice = os.getenv("TTS_VOICE_KO", "ko-KR-SunHiNeural")
+        en_voice = os.getenv("TTS_VOICE_EN", "en-US-AriaNeural")
+
+        if total_letters == 0:
+            active_voice = TTS_VOICE
+        elif (hangul_chars / total_letters) >= 0.3:
+            active_voice = ko_voice
+        else:
+            active_voice = en_voice
+        communicate = edge_tts.Communicate(clean, active_voice)
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
+            tmp = f.name
+        await communicate.save(tmp)
+        data = Path(tmp).read_bytes()
+        os.unlink(tmp)
+        return data
+    except Exception as e:
+        logger.error(f"TTS error: {e}")
+        return None
+
+
+async def stt(audio_bytes: bytes) -> str | None:
+    try:
+
+        def _transcribe():
+            import io
+
+            import speech_recognition as sr
+
+            r = sr.Recognizer()
+            with sr.AudioFile(io.BytesIO(audio_bytes)) as source:
+                audio = r.record(source)
+            try:
+                return r.recognize_google(audio, language="ko-KR")
+            except sr.UnknownValueError:
+                return None
+            except sr.RequestError as e:
+                logger.error(f"STT API error: {e}")
+                return None
+
+        result = await asyncio.to_thread(_transcribe)
+        return result.strip() if result else None
+    except Exception as e:
+        logger.error(f"STT internal error: {e}")
+        return None

package/src/services/discord_helpers.py

@@ -0,0 +1,95 @@
+import re
+import string
+import uuid
+from pathlib import Path
+
+import discord
+
+from config import TMP_FILE_DIR, logger
+
+
+async def handle_image_attachments(message: discord.Message) -> list[str]:
+    saved_paths = []
+    for att in message.attachments:
+        ext = Path(att.filename).suffix.lower()
+        filename = f"{uuid.uuid4().hex}{ext or '.tmp'}"
+        dest = TMP_FILE_DIR / filename
+        try:
+            data = await att.read()
+            dest.write_bytes(data)
+            saved_paths.append(str(dest))
+        except Exception as e:
+            logger.error(f"Image save failed: {e}")
+    return saved_paths
+
+
+def cleanup_images(image_paths: list[str]):
+    for path in image_paths:
+        try:
+            Path(path).unlink(missing_ok=True)
+        except Exception as e:
+            logger.warning(f"Failed to delete temp image {path}: {e}")
+
+
+def build_content_with_images(content: str, image_paths: list[str]) -> str:
+    parts = []
+    parts.append(content)
+
+    if not image_paths:
+        return "\n".join(parts)
+
+    parts.append("\n\n[Attached file path (use `view_file` tool to analyze)]")
+    for path in image_paths:
+        parts.append(f"- {path}")
+    return "\n".join(parts)
+
+
+def clean_ansi(text: str) -> str:
+    return re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])").sub("", text)
+
+
+def check_approval_intent(text: str) -> str:
+    lower_c = text.strip().lower()
+    neg_kr_substr = ["아니", "거절", "취소", "하지마", "안돼", "싫어", "멈춰", "그만", "안해", "노노"]
+    for neg in neg_kr_substr:
+        if neg in lower_c:
+            return "reject"
+    pos_kr_substr = ["진행", "승인", "하라고", "해봐", "해라", "실행", "그래", "알았어", "좋아", "수락", "오케이"]
+    for pos in pos_kr_substr:
+        if pos in lower_c:
+            return "allow"
+
+    clean_text = lower_c.translate(str.maketrans("", "", string.punctuation))
+    words = clean_text.split()
+    exact_reject = ["no", "cancel", "stop", "reject", "deny", "n", "ㄴㄴ", "nope", "abort", "quit", "never"]
+    exact_allow = [
+        "yes",
+        "ok",
+        "okay",
+        "go",
+        "approve",
+        "allow",
+        "y",
+        "응",
+        "어",
+        "ㅇㅇ",
+        "ㅇㅋ",
+        "해",
+        "콜",
+        "네",
+        "sure",
+        "yeah",
+        "yep",
+        "yup",
+        "proceed",
+        "fine",
+        "alright",
+        "고",
+    ]
+    for word in words:
+        if word in exact_reject:
+            return "reject"
+    for word in words:
+        if word in exact_allow:
+            return "allow"
+    return None

package/src/services/discord_mcp.py

@@ -0,0 +1,50 @@
+import os
+
+import requests
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("DiscordButtons")
+
+
+@mcp.tool()
+def ask_discord_user(question: str, options: list[str]) -> str:
+    """
+    Ask a multiple-choice question to the user in Discord using interactive buttons.
+    You MUST use this tool instead of the default ask_question tool when running in Discord.
+    """
+    thread_id = os.environ.get("DISCORD_THREAD_ID")
+    if not thread_id:
+        return "Error: DISCORD_THREAD_ID not set. Are you running in Discord?"
+
+    try:
+        resp = requests.post(
+            "http://127.0.0.1:18080/mcp_ask",
+            json={"thread_id": thread_id, "question": question, "options": options},
+            timeout=300,
+        )
+        if resp.status_code == 200:
+            return resp.json().get("answer", "No answer")
+        return f"Error: HTTP {resp.status_code}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+@mcp.tool()
+def send_discord_message(channel_id: str, message: str) -> str:
+    """
+    Sends a text message to a specific Discord channel by its ID.
+    You can use this tool when the user asks you to send a message to a different channel.
+    """
+    try:
+        resp = requests.post(
+            "http://127.0.0.1:18080/mcp_send_channel", json={"channel_id": channel_id, "message": message}, timeout=10
+        )
+        if resp.status_code == 200:
+            return "Message sent successfully"
+        return f"Error: HTTP {resp.status_code} - {resp.text}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+if __name__ == "__main__":
+    mcp.run()

package/src/services/response.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+from typing import Any
+
+from config import MAX_EMBED_LEN, MODEL_CHOICES, session_manager
+from messengers.registry import get_adapter
+from utils.utils import get_current_model
+
+
+async def send_agy_response(
+    thread: Any,
+    response_text: str,
+    session: dict,
+    ctx: dict = None,
+    start_time: float = 0,
+    conv_id: str = None,
+):
+    adapter = get_adapter()
+    session_manager.save_sessions()
+
+    parts = [response_text[i : i + MAX_EMBED_LEN] for i in range(0, max(len(response_text), 1), MAX_EMBED_LEN)]
+    for idx, part in enumerate(parts):
+        is_last = idx == len(parts) - 1
+
+        if is_last:
+            if not part.strip():
+                continue
+
+            session_model = session.get("model")
+            model_display = MODEL_CHOICES.get(session_model, session_model) if session_model else get_current_model()
+            text_to_send = f"{part}\n-# 🤖 {model_display}"
+
+            status_msg = ctx.get("status_msg") if ctx else None
+            if status_msg and await adapter.edit_message(status_msg, text_to_send):
+                continue
+            await adapter.send_message(thread, text_to_send)
+        else:
+            await adapter.send_message(thread, part)
+
+    files_to_send = []
+    if conv_id and start_time:
+        brain_dir = Path.home() / f".gemini/antigravity-cli/brain/{conv_id}"
+        if brain_dir.exists():
+            for md_file in brain_dir.glob("*.md"):
+                if md_file.stat().st_mtime >= start_time:
+                    files_to_send.append(str(md_file))
+    if files_to_send:
+        await adapter.send_files(thread, files_to_send)
+
+
+async def render_thought_process(conv_id: str, ctx: dict, response_text: str, thread: Any) -> str:
+    return ctx.get("final_text", response_text)