remote-coder 0.4.1__py3-none-any.whl

app/telegram/model_preferences.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from threading import Lock
+
+from app.models import ModelName
+
+
+@dataclass(frozen=True)
+class ModelPreference:
+    provider: ModelName
+    model_id: str | None = None
+
+
+class InMemoryModelPreferenceStore:
+    def __init__(self, default_model: ModelName) -> None:
+        self._default_model = default_model
+        self._values: dict[tuple[str | None, int], ModelPreference] = {}
+        self._lock = Lock()
+
+    def get(self, project_name: str | None, chat_id: int) -> ModelName:
+        with self._lock:
+            selection = self._values.get((project_name, chat_id))
+            return selection.provider if selection is not None else self._default_model
+
+    def get_explicit(self, project_name: str | None, chat_id: int) -> ModelName | None:
+        with self._lock:
+            selection = self._values.get((project_name, chat_id))
+            return selection.provider if selection is not None else None
+
+    def set(self, project_name: str | None, chat_id: int, model: ModelName) -> None:
+        self.set_selection(project_name, chat_id, ModelPreference(model))
+
+    def get_explicit_selection(
+        self,
+        project_name: str | None,
+        chat_id: int,
+    ) -> ModelPreference | None:
+        with self._lock:
+            return self._values.get((project_name, chat_id))
+
+    def set_selection(
+        self,
+        project_name: str | None,
+        chat_id: int,
+        selection: ModelPreference,
+    ) -> None:
+        with self._lock:
+            self._values[(project_name, chat_id)] = selection
+
+    def clear(self, project_name: str | None, chat_id: int) -> None:
+        with self._lock:
+            self._values.pop((project_name, chat_id), None)

app/telegram/notifier.py

@@ -0,0 +1,387 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Protocol
+
+import httpx
+
+from app.ai.model_catalog import format_model_selection
+from app.ai.usage import format_token_usage
+from app.jobs.schemas import Job, JobMode
+from app.monitoring.events import EventLogger
+from app.telegram.i18n import language_from_settings_store, translate_button_label, translate_text, ui_message
+
+_outbound = EventLogger("app.telegram.outbound", "telegram.outbound")
+
+
+class Notifier(Protocol):
+    def send_text(self, chat_id: int, text: str, *, skip_body_i18n: bool = False) -> int | None: ...
+
+    def send_with_buttons(
+        self,
+        chat_id: int,
+        text: str,
+        inline_buttons: list,
+        *,
+        skip_body_i18n: bool = False,
+    ) -> int | None: ...
+
+    def answer_callback_query(self, callback_query_id: str) -> None: ...
+
+    def send_job_accepted(self, job: Job) -> int | None: ...
+
+    def send_job_result(self, job: Job) -> list[int]: ...
+
+    def send_long_text(self, chat_id: int, text: str) -> list[int]: ...
+
+
+@dataclass
+class _OutboundButton:
+    label: str
+    callback_data: str
+
+
+def build_job_accepted_message(job: Job) -> tuple[str, list[list[_OutboundButton]]]:
+    mode_line = ""
+    if job.request.mode is JobMode.PLAN:
+        mode_line = ui_message("job.mode_line", "\n- Mode: {mode}", mode="plan")
+    elif job.request.mode is JobMode.ASK:
+        mode_line = ui_message("job.mode_line", "\n- Mode: {mode}", mode="ask")
+    text = ui_message(
+        "job.accepted",
+        "✅ Job accepted\n\n"
+        "- Job ID: {job_id}\n"
+        "- Project: {project}\n"
+        "- Model: {model}{mode_line}",
+        job_id=job.id,
+        project=job.request.project,
+        model=format_model_selection(job.request.model, job.request.model_id),
+        mode_line=mode_line,
+    )
+    buttons = [[_OutboundButton(ui_message("job.stop_button", "Stop job"), f"/stop {job.id}")]]
+    return text, buttons
+
+
+def _ui_response_block(summary: str | None) -> str:
+    if not summary:
+        return ""
+    return ui_message("job.response_block", "\n\nAI response:\n{summary}", summary=summary)
+
+
+def _ui_failure_details(job: Job) -> str:
+    details: list[str] = []
+    if job.error_stage:
+        details.append(
+            ui_message("job.failure_detail_stage", "\n- Failure stage: {stage}", stage=job.error_stage)
+        )
+    if job.log_path:
+        details.append(
+            ui_message("job.failure_detail_log_path", "\n- Log path: {log_path}", log_path=job.log_path)
+        )
+    return "".join(details)
+
+
+def _ui_failure_block(summary: str | None) -> str:
+    if not summary:
+        return ""
+    return ui_message("job.failure_block", "\n\nFailure output summary:\n{summary}", summary=summary)
+
+
+def _ui_token_usage(job: Job) -> str:
+    return format_token_usage(job.runner_token_usage) or ui_message(
+        "common.unavailable",
+        "unavailable",
+    )
+
+
+def build_job_result_message(job: Job) -> str:
+    mode_prefix = ""
+    if job.request.mode is JobMode.PLAN:
+        mode_prefix = "[plan] "
+    elif job.request.mode is JobMode.ASK:
+        mode_prefix = "[ask] "
+
+    if job.status.value == "cancelled":
+        return ui_message(
+            "job.cancelled",
+            "{mode_prefix}⛔ Job cancelled\n\n- Job ID: {job_id}\n- Project: {project}",
+            mode_prefix=mode_prefix,
+            job_id=job.id,
+            project=job.request.project,
+        )
+
+    if job.status.value == "succeeded":
+        if job.request.mode in (JobMode.PLAN, JobMode.ASK):
+            label = "plan" if job.request.mode is JobMode.PLAN else "ask"
+            model_label = job.runner_actual_model or format_model_selection(
+                job.request.model,
+                job.request.model_id,
+            )
+            return ui_message(
+                "job.readonly_completed",
+                "[{mode}] Completed\n\n"
+                "- Job ID: {job_id}\n"
+                "- Project: {project}\n"
+                "- Model used: {model}\n"
+                "- Token usage: {token_usage}{response_block}",
+                mode=label,
+                job_id=job.id,
+                project=job.request.project,
+                model=model_label,
+                token_usage=_ui_token_usage(job),
+                response_block=_ui_response_block(job.runner_stdout_summary),
+            )
+
+        changed = ", ".join(job.changed_files) if job.changed_files else ui_message(
+            "job.no_changes",
+            "No changes",
+        )
+        branch_line = job.branch if job.branch else ui_message(
+            "job.branch_none_no_changes",
+            "(none - no branch; no changes)",
+        )
+        commit_line = job.commit_hash or "-"
+        if job.changed_files and not job.request.commit:
+            commit_line = ui_message("job.no_commit_skipped", "(no commit - commit/push skipped)")
+        elif job.changed_files and job.request.commit and not job.commit_hash:
+            commit_line = ui_message("job.nothing_staged_skipped", "(nothing staged - push skipped)")
+        model_label = job.runner_actual_model or format_model_selection(
+            job.request.model,
+            job.request.model_id,
+        )
+        return ui_message(
+            "job.completed",
+            "✅ Job completed\n\n"
+            "- Job ID: {job_id}\n"
+            "- Project: {project}\n"
+            "- Branch: {branch}\n"
+            "- Commit: {commit}\n"
+            "- Changed files: {changed}\n"
+            "- Model used: {model}\n"
+            "- Token usage: {token_usage}{response_block}",
+            job_id=job.id,
+            project=job.request.project,
+            branch=branch_line,
+            commit=commit_line,
+            changed=changed,
+            model=model_label,
+            token_usage=_ui_token_usage(job),
+            response_block=_ui_response_block(job.runner_stdout_summary),
+        )
+
+    failure_summary = job.runner_stderr_summary or job.runner_stdout_summary
+    return ui_message(
+        "job.failed",
+        "{mode_prefix}❌ Job failed\n\n"
+        "- Job ID: {job_id}\n"
+        "- Project: {project}\n"
+        "- Error: {error}{details}{failure_block}",
+        mode_prefix=mode_prefix,
+        job_id=job.id,
+        project=job.request.project,
+        error=job.error or "unknown error",
+        details=_ui_failure_details(job),
+        failure_block=_ui_failure_block(failure_summary),
+    )
+
+
+class TelegramNotifier:
+    _TELEGRAM_TEXT_LIMIT = 4096
+    _MAX_ATTEMPTS = 3
+
+    def __init__(self, bot_token: str, advanced_settings_store=None) -> None:
+        self._api_url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
+        self._callback_answer_url = f"https://api.telegram.org/bot{bot_token}/answerCallbackQuery"
+        self._advanced_settings_store = advanced_settings_store
+
+    @property
+    def _language(self):
+        return language_from_settings_store(self._advanced_settings_store)
+
+    @staticmethod
+    def _extract_message_id(response: httpx.Response) -> int | None:
+        try:
+            data = response.json()
+        except ValueError:
+            return None
+        result = data.get("result") if isinstance(data, dict) else None
+        message_id = result.get("message_id") if isinstance(result, dict) else None
+        return int(message_id) if message_id is not None else None
+
+    def _post_with_retry(
+        self,
+        url: str,
+        payload: dict,
+        *,
+        log_label: str,
+        chat_id: int | None = None,
+    ) -> httpx.Response | None:
+        for attempt in range(1, self._MAX_ATTEMPTS + 1):
+            try:
+                response = httpx.post(url, json=payload, timeout=httpx.Timeout(10.0, connect=5.0))
+                response.raise_for_status()
+                return response
+            except httpx.HTTPError as exc:
+                _outbound.warning(
+                    "%s attempt failed attempt=%d/%d err=%s",
+                    log_label,
+                    attempt,
+                    self._MAX_ATTEMPTS,
+                    type(exc).__name__,
+                    chat_id=chat_id,
+                )
+                if attempt == self._MAX_ATTEMPTS:
+                    _outbound.warning(
+                        "%s failed after %d attempts: %s",
+                        log_label,
+                        self._MAX_ATTEMPTS,
+                        type(exc).__name__,
+                        chat_id=chat_id,
+                    )
+                    return None
+                time.sleep(attempt)
+        return None
+
+    def _post_message(self, chat_id: int, text: str) -> int | None:
+        _outbound.info("sendMessage start len=%d", len(text), chat_id=chat_id)
+        response = self._post_with_retry(
+            self._api_url,
+            {"chat_id": chat_id, "text": text},
+            log_label="sendMessage",
+            chat_id=chat_id,
+        )
+        if response is None:
+            return None
+        _outbound.info("sent text len=%d status=%d", len(text), response.status_code, chat_id=chat_id)
+        return self._extract_message_id(response)
+
+    def send_text(self, chat_id: int, text: str, *, skip_body_i18n: bool = False) -> int | None:
+        out = text if skip_body_i18n else translate_text(text, self._language)
+        return self._post_message(chat_id, out)
+
+    def send_with_buttons(
+        self,
+        chat_id: int,
+        text: str,
+        inline_buttons: list,
+        *,
+        skip_body_i18n: bool = False,
+    ) -> int | None:
+        language = self._language
+        out_text = text if skip_body_i18n else translate_text(text, language)
+        keyboard = [
+            [
+                {"text": translate_button_label(btn.label, language), "callback_data": btn.callback_data}
+                for btn in row
+            ]
+            for row in inline_buttons
+        ]
+        payload = {
+            "chat_id": chat_id,
+            "text": out_text,
+            "reply_markup": {"inline_keyboard": keyboard},
+        }
+        button_count = sum(len(row) for row in inline_buttons)
+        _outbound.info(
+            "sendMessage buttons start len=%d rows=%d buttons=%d",
+            len(out_text),
+            len(inline_buttons),
+            button_count,
+            chat_id=chat_id,
+        )
+        response = self._post_with_retry(
+            self._api_url,
+            payload,
+            log_label="sendMessage (buttons)",
+            chat_id=chat_id,
+        )
+        if response is None:
+            return None
+        _outbound.info(
+            "sent message with buttons len=%d status=%d",
+            len(out_text),
+            response.status_code,
+            chat_id=chat_id,
+        )
+        return self._extract_message_id(response)
+
+    def answer_callback_query(self, callback_query_id: str) -> None:
+        _outbound.info("answerCallbackQuery start")
+        response = self._post_with_retry(
+            self._callback_answer_url,
+            {"callback_query_id": callback_query_id},
+            log_label="answerCallbackQuery",
+        )
+        if response is not None:
+            _outbound.info("answerCallbackQuery sent status=%d", response.status_code)
+
+    def send_job_accepted(self, job: Job) -> int | None:
+        _outbound.info(
+            "notify job accepted",
+            chat_id=job.request.chat_id,
+            job_id=job.id,
+            project=job.request.project,
+        )
+        text, buttons = build_job_accepted_message(job)
+        return self.send_with_buttons(job.request.chat_id, text, buttons)
+
+    def send_job_result(self, job: Job) -> list[int]:
+        _outbound.info(
+            "notify job result status=%s changed_files=%d",
+            job.status.value,
+            len(job.changed_files),
+            chat_id=job.request.chat_id,
+            job_id=job.id,
+            project=job.request.project,
+        )
+        return self.send_long_text(job.request.chat_id, build_job_result_message(job))
+
+    def send_long_text(self, chat_id: int, text: str) -> list[int]:
+        """Split text across Telegram messages when it exceeds the 4096-character limit."""
+        outgoing = translate_text(text, self._language)
+        chunks = self._chunk_text(outgoing, self._TELEGRAM_TEXT_LIMIT)
+        _outbound.info(
+            "send_long_text chunks=%d total_len=%d",
+            len(chunks),
+            len(outgoing),
+            chat_id=chat_id,
+        )
+        message_ids: list[int] = []
+        for idx, chunk in enumerate(chunks, 1):
+            _outbound.info(
+                "send_long_text chunk=%d/%d len=%d",
+                idx,
+                len(chunks),
+                len(chunk),
+                chat_id=chat_id,
+            )
+            message_id = self._post_message(chat_id, chunk)
+            if message_id is not None:
+                message_ids.append(message_id)
+        return message_ids
+
+    @staticmethod
+    def _chunk_text(text: str, max_len: int) -> list[str]:
+        if max_len <= 0:
+            raise ValueError("max_len must be positive")
+        if len(text) <= max_len:
+            return [text]
+        chunks: list[str] = []
+        i = 0
+        n = len(text)
+        min_break = max_len // 2
+        while i < n:
+            j = min(i + max_len, n)
+            if j < n:
+                segment = text[i:j]
+                cut = segment.rfind("\n")
+                if cut >= min_break:
+                    j = i + cut + 1
+                else:
+                    cut = segment.rfind(" ")
+                    if cut >= min_break:
+                        j = i + cut + 1
+            chunks.append(text[i:j])
+            i = j
+        return chunks

app/telegram/parser.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import re
+
+from app.git.service import GitWorktreeService
+from app.jobs.schemas import JobMode, JobRequest
+from app.models import ModelName
+from app.projects.registry import ProjectRegistry
+from app.telegram.conversation import (
+    ConversationContextBuilder,
+    SQLiteConversationStore,
+    is_ambiguous_followup,
+)
+from app.telegram.i18n import (
+    command_parse_error_disabled_project,
+    command_parse_error_empty_instruction,
+    command_parse_error_empty_instruction_plan_ask,
+    command_parse_error_no_previous_job_context,
+    command_parse_error_unknown_project,
+    instruction_frame_labels,
+    language_from_settings_store,
+    localize_git_branch_validation_message,
+)
+from app.telegram.model_preferences import InMemoryModelPreferenceStore, ModelPreference
+
+
+class CommandParseError(ValueError):
+    pass
+
+
+_MODEL_OPTION_PATTERN = "|".join(model.value for model in ModelName)
+
+_SLASH_PLAN_ASK = re.compile(r"^/(plan|ask)\b\s*", re.IGNORECASE)
+_PREFIX_PLAN_ASK = re.compile(
+    r"^(plan|ask|계획|질문)\s*[:：]\s*",
+    re.IGNORECASE,
+)
+_REPLY_JOB_ID_PATTERN = re.compile(
+    r"\bJob ID:\s*`?([A-Za-z0-9_.:-]+)`?",
+    re.IGNORECASE,
+)
+
+
+def _job_mode_from_plan_ask_keyword(key: str) -> JobMode:
+    lowered = key.lower()
+    if lowered in ("plan", "계획"):
+        return JobMode.PLAN
+    if lowered in ("ask", "질문"):
+        return JobMode.ASK
+    raise AssertionError(key)
+
+
+def _extract_reply_job_id(text: str) -> str | None:
+    match = _REPLY_JOB_ID_PATTERN.search(text)
+    return match.group(1) if match else None
+
+
+class CommandParser:
+    def __init__(
+        self,
+        project_registry: ProjectRegistry,
+        default_model: ModelName,
+        model_preferences: InMemoryModelPreferenceStore | None = None,
+        conversation_store: SQLiteConversationStore | None = None,
+        conversation_recent_limit: int = 10,
+        advanced_settings_store=None,
+    ) -> None:
+        self._project_registry = project_registry
+        self._default_model = default_model
+        self._model_preferences = model_preferences
+        self._conversation_store = conversation_store
+        self._conversation_recent_limit = conversation_recent_limit
+        self._advanced_settings_store = advanced_settings_store
+
+    @staticmethod
+    def _extract_options(
+        text: str,
+    ) -> tuple[ModelName | None, str | None, bool | None, str]:
+        remaining = text
+        model: ModelName | None = None
+        branch: str | None = None
+        commit: bool | None = None
+
+        model_match = re.search(
+            rf"\bmodel:\s*({_MODEL_OPTION_PATTERN})\b",
+            remaining,
+            flags=re.IGNORECASE,
+        )
+        if model_match:
+            model = ModelName(model_match.group(1).lower())
+            remaining = re.sub(
+                rf"\bmodel:\s*({_MODEL_OPTION_PATTERN})\b",
+                "",
+                remaining,
+                flags=re.IGNORECASE,
+            ).strip()
+
+        branch_match = re.search(r"\bbranch:\s*([A-Za-z0-9._/\-]+)", remaining, flags=re.IGNORECASE)
+        if branch_match:
+            branch = branch_match.group(1)
+            remaining = re.sub(r"\bbranch:\s*([A-Za-z0-9._/\-]+)", "", remaining, flags=re.IGNORECASE).strip()
+
+        no_commit_match = re.search(r"\bno\s+commit\b", remaining, flags=re.IGNORECASE)
+        if no_commit_match:
+            commit = False
+            remaining = re.sub(r"\bno\s+commit\b", "", remaining, flags=re.IGNORECASE).strip()
+
+        return model, branch, commit, remaining
+
+    @staticmethod
+    def _strip_leading_job_mode(text: str) -> tuple[JobMode, str]:
+        stripped = text.strip()
+        slash = _SLASH_PLAN_ASK.match(stripped)
+        if slash:
+            key = slash.group(1).lower()
+            mode = JobMode.PLAN if key == "plan" else JobMode.ASK
+            return mode, stripped[slash.end() :].strip()
+        prefix = _PREFIX_PLAN_ASK.match(stripped)
+        if prefix:
+            mode = _job_mode_from_plan_ask_keyword(prefix.group(1))
+            return mode, stripped[prefix.end() :].strip()
+        return JobMode.AGENT, stripped
+
+    def parse_natural(
+        self,
+        text: str,
+        project_name: str,
+        chat_id: int,
+        user_id: int | None,
+        message_id: int | None = None,
+        reply_to_message_id: int | None = None,
+        reply_to_text: str | None = None,
+    ) -> JobRequest:
+        lang = language_from_settings_store(self._advanced_settings_store)
+        mode, stripped = self._strip_leading_job_mode(text)
+
+        model, branch, commit, remaining = self._extract_options(stripped)
+        if mode in (JobMode.PLAN, JobMode.ASK):
+            branch = None
+            commit = False
+
+        if not remaining:
+            if mode in (JobMode.PLAN, JobMode.ASK):
+                raise CommandParseError(command_parse_error_empty_instruction_plan_ask(lang))
+            raise CommandParseError(command_parse_error_empty_instruction(lang))
+
+        entry = self._project_registry.get(project_name)
+        if not entry:
+            raise CommandParseError(command_parse_error_unknown_project(project_name, lang))
+        if not entry.enabled:
+            raise CommandParseError(command_parse_error_disabled_project(project_name, lang))
+
+        selected_model: ModelName
+        selected_model_id: str | None = None
+        if model is not None:
+            selected_model = model
+        elif self._model_preferences is not None:
+            selection = self._model_preferences.get_explicit_selection(project_name, chat_id)
+            if selection is None:
+                selection = ModelPreference(entry.default_model)
+            selected_model = selection.provider
+            selected_model_id = selection.model_id
+        else:
+            selected_model = entry.default_model
+
+        if (
+            mode == JobMode.AGENT
+            and branch is None
+            and reply_to_message_id is not None
+            and self._conversation_store is not None
+        ):
+            branch = self._conversation_store.get_bound_branch(
+                project_name,
+                chat_id,
+                reply_to_message_id,
+            )
+
+        if branch is not None:
+            branch_err = GitWorktreeService.validate_branch_token(branch)
+            if branch_err:
+                raise CommandParseError(localize_git_branch_validation_message(branch_err, lang))
+
+        instruction_body = remaining.strip()
+        reply_job_id: str | None = None
+        if reply_to_message_id is not None and self._conversation_store is not None:
+            reply_job_id = self._conversation_store.get_job_id_for_message_id(
+                project_name,
+                chat_id,
+                reply_to_message_id,
+            )
+        reply_prefix = ""
+        if reply_to_message_id is not None and self._conversation_store is not None:
+            reply_prefix = self._conversation_store.format_reply_context(
+                project_name,
+                chat_id,
+                reply_to_message_id,
+                lang,
+            ).strip()
+        if not reply_prefix and reply_to_message_id is not None and reply_to_text:
+            frame = instruction_frame_labels(lang)
+            if self._conversation_store is not None:
+                extracted_reply_job_id = _extract_reply_job_id(reply_to_text)
+                if extracted_reply_job_id:
+                    reply_job_id = extracted_reply_job_id
+                    reply_prefix = self._conversation_store.format_job_context(
+                        project_name,
+                        chat_id,
+                        extracted_reply_job_id,
+                        lang,
+                    ).strip()
+            if not reply_prefix:
+                reply_prefix = "\n".join(
+                    [
+                        frame.reply_message_open,
+                        f"message_id={reply_to_message_id}:",
+                        f"  text: {reply_to_text.strip()}",
+                        frame.reply_message_close,
+                    ]
+                )
+
+        chain_message_ids: set[int] = set()
+        if reply_to_message_id is not None and self._conversation_store is not None:
+            chain_message_ids = self._conversation_store.collect_reply_chain_message_ids(
+                project_name,
+                chat_id,
+                reply_to_message_id,
+            )
+
+        if is_ambiguous_followup(instruction_body) and self._conversation_store is not None:
+            entries = self._conversation_store.list_recent(
+                project_name,
+                chat_id,
+                self._conversation_recent_limit,
+            )
+            filtered = [
+                e
+                for e in entries
+                if e.message_id is None or e.message_id not in chain_message_ids
+            ]
+            if not filtered:
+                if not reply_prefix:
+                    raise CommandParseError(command_parse_error_no_previous_job_context(lang))
+                instruction = f"{reply_prefix}\n\n{instruction_body}".strip()
+            else:
+                inner = ConversationContextBuilder.build(filtered, instruction_body, lang)
+                instruction = f"{reply_prefix}\n\n{inner}".strip() if reply_prefix else inner
+        elif reply_prefix:
+            instruction = f"{reply_prefix}\n\n{instruction_body}".strip()
+        else:
+            instruction = instruction_body
+
+        effective_commit = False if mode in (JobMode.PLAN, JobMode.ASK) else (True if commit is None else commit)
+
+        return JobRequest(
+            project=project_name,
+            model=selected_model,
+            model_id=selected_model_id,
+            instruction=instruction,
+            mode=mode,
+            branch=branch,
+            commit=effective_commit,
+            chat_id=chat_id,
+            requested_by=user_id,
+            message_id=message_id,
+            reply_to_message_id=reply_to_message_id,
+            job_id=reply_job_id,
+        )