remote-coder 0.4.1__py3-none-any.whl

app/telegram/commands/clear_stop.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from app.jobs.schemas import Job, JobStatus
+from app.projects.registry import ProjectRecord
+from app.telegram.commands.base import (
+    CommandContext,
+    ConfirmableCommand,
+    InlineButton,
+    TelegramCommand,
+    TelegramMessage,
+    _button_rows,
+    _cmd_evt,
+    _confirmation_buttons_enabled,
+    _job_button_label,
+    effective_project_name_for_chat,
+)
+from app.telegram.confirmations import PendingConfirmation
+
+
+class ClearCommand(ConfirmableCommand):
+    name = "/clear"
+    description = "Clean branches, worktrees, or conversation memory after confirmation"
+
+    def execute(self, message: TelegramMessage, ctx: CommandContext) -> str:
+        tokens = message.text.strip().split()
+        if len(tokens) == 1:
+            return "Choose what to clear. Confirmation with y/Y is required before running."
+        if len(tokens) != 2 or tokens[1] not in {"branch", "memory", "worktrees"}:
+            return "Usage: /clear branch or /clear worktrees or /clear memory"
+
+        action = tokens[1]
+        if action == "memory" and ctx.conversation_store is None:
+            return "Memory store is not configured."
+
+        ctx.confirmation_store.set(
+            effective_project_name_for_chat(ctx, message.chat_id),
+            message.chat_id,
+            PendingConfirmation(command_name=self.name, action=action),
+        )
+
+        if action == "branch":
+            summary = "Delete remote-* branches and their linked worktrees in this bot project."
+        elif action == "worktrees":
+            summary = "Clean managed worktrees and prune stale entries in this bot project."
+        else:
+            summary = "Delete only this chat's conversation memory in this bot project."
+        if _confirmation_buttons_enabled(ctx):
+            return f"Pending action: {summary}\nChoose whether to run it."
+        return (
+            f"Pending action: {summary}\n"
+            "Send y or Y to run it. Any other response cancels it."
+        )
+
+    def get_inline_buttons(
+        self,
+        message: TelegramMessage | None = None,
+        ctx: CommandContext | None = None,
+    ) -> list[list[InlineButton]] | None:
+        if message is None or ctx is None:
+            return None
+        tokens = message.text.strip().split()
+        if len(tokens) == 1:
+            return [
+                [
+                    InlineButton("branch", "/clear branch"),
+                    InlineButton("worktrees", "/clear worktrees"),
+                    InlineButton("memory", "/clear memory"),
+                ],
+            ]
+        if not _confirmation_buttons_enabled(ctx):
+            return None
+        pending = ctx.confirmation_store.get(
+            effective_project_name_for_chat(ctx, message.chat_id),
+            message.chat_id,
+        )
+        if pending is None or pending.command_name != self.name:
+            return None
+        return [[InlineButton("Yes", "Y"), InlineButton("No", "n")]]
+
+    def confirm(
+        self,
+        message: TelegramMessage,
+        ctx: CommandContext,
+        pending: PendingConfirmation,
+    ) -> str:
+        if message.text.strip() not in {"y", "Y"}:
+            if pending.action == "branch":
+                target = "Branch cleanup"
+            elif pending.action == "worktrees":
+                target = "Worktree cleanup"
+            else:
+                target = "Memory cleanup"
+            return f"{target} was cancelled."
+
+        _cmd_evt.info("clear confirmed action=%s", pending.action, chat_id=message.chat_id)
+        if pending.action == "branch":
+            return self._clear_branches(ctx)
+        if pending.action == "worktrees":
+            return self._clear_worktrees(ctx)
+        if pending.action == "memory":
+            return self._clear_memory(ctx, message.chat_id)
+        return "Unknown clear action."
+
+    def _bound_project_record(self, ctx: CommandContext) -> ProjectRecord | None:
+        name = ctx.project_name
+        if not name:
+            return None
+        return ctx.project_registry.get(name)
+
+    def _clear_branches(self, ctx: CommandContext) -> str:
+        p = self._bound_project_record(ctx)
+        if p is None:
+            return "No project is bound to this bot or the project was not found in the registry."
+        if not p.enabled:
+            return f"Project is disabled: {p.name}"
+
+        try:
+            ctx.git_service.checkout_integrate_branch(p.root_path)
+            remote_branches = ctx.git_service.list_remote_branches_matching(
+                p.root_path, ctx.git_remote_name, "remote-"
+            )
+            local_branches = ctx.git_service.list_local_branches_matching(p.root_path, "remote-")
+            if remote_branches:
+                ctx.git_service.delete_remote_branches(p.root_path, ctx.git_remote_name, remote_branches)
+            if local_branches:
+                ctx.git_service.remove_linked_worktrees_for_branches(p.root_path, local_branches)
+                ctx.git_service.delete_local_branches(p.root_path, local_branches)
+            return (
+                f"{p.name}: remote {len(remote_branches)}, local {len(local_branches)} deleted "
+                f"({ctx.git_remote_name})"
+            )
+        except RuntimeError as exc:
+            return f"{p.name}: failed - {exc}"
+
+    def _clear_memory(self, ctx: CommandContext, chat_id: int) -> str:
+        if ctx.conversation_store is None:
+            return "Memory store is not configured."
+        project_name = ctx.project_name
+        if not project_name:
+            return "No project is bound to this bot."
+        entries_removed, links_removed = ctx.conversation_store.delete_chat_memory(
+            project=project_name, chat_id=chat_id
+        )
+        return (
+            f"Deleted this chat's conversation memory. "
+            f"(project={project_name}, entries {entries_removed}, branch links {links_removed})"
+        )
+
+    def _clear_worktrees(self, ctx: CommandContext) -> str:
+        p = self._bound_project_record(ctx)
+        if p is None:
+            return "No project is bound to this bot or the project was not found in the registry."
+        if not p.enabled:
+            return f"Project is disabled: {p.name}"
+
+        try:
+            removed_count = ctx.git_service.cleanup_managed_worktrees(
+                p.root_path,
+                p.worktree_base_dir,
+                branch_prefix="remote-",
+            )
+            return f"{p.name}: {removed_count} worktrees deleted, stale entries pruned"
+        except RuntimeError as exc:
+            return f"{p.name}: failed - {exc}"
+
+
+class StopCommand(TelegramCommand):
+    name = "/stop"
+    description = "Choose and stop a running job"
+
+    def execute(self, message: TelegramMessage, ctx: CommandContext) -> str:
+        tokens = message.text.strip().split(maxsplit=1)
+        if len(tokens) < 2:
+            jobs = self._list_cancellable_jobs(message, ctx)
+            if not jobs:
+                return "No running job can be stopped."
+            return "Choose a job to stop."
+        job_id = tokens[1].strip()
+        project_name = effective_project_name_for_chat(ctx, message.chat_id)
+        existing = ctx.job_store.get(job_id)
+        if existing is not None and project_name and existing.request.project != project_name:
+            return f"Job not found: {job_id}"
+        if ctx.job_manager is None:
+            return "Job cancellation is not available."
+        success = ctx.job_manager.cancel(job_id)
+        if success:
+            return f"Stop requested: {job_id}"
+        job = ctx.job_store.get(job_id)
+        if not job:
+            return f"Job not found: {job_id}"
+        return f"Cannot stop job: {job_id} (current status: {job.status.value})"
+
+    def get_inline_buttons(
+        self,
+        message: TelegramMessage | None = None,
+        ctx: CommandContext | None = None,
+    ) -> list[list[InlineButton]] | None:
+        if message is None or ctx is None:
+            return None
+        if len(message.text.strip().split()) != 1:
+            return None
+        jobs = self._list_cancellable_jobs(message, ctx)
+        if not jobs:
+            return None
+        return _button_rows(
+            [InlineButton(_job_button_label(job), f"/stop {job.id}") for job in jobs],
+            per_row=1,
+        )
+
+    @staticmethod
+    def _list_cancellable_jobs(message: TelegramMessage, ctx: CommandContext) -> list[Job]:
+        project_name = effective_project_name_for_chat(ctx, message.chat_id)
+        if not project_name:
+            return []
+        return [
+            job
+            for job in ctx.job_store.list_recent_for_project_chat(
+                project_name, message.chat_id, 20
+            )
+            if job.status in {JobStatus.QUEUED, JobStatus.RUNNING}
+        ]

app/telegram/commands/fix.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+from app.jobs.schemas import FixKind, Job, JobMode, JobRequest
+from app.telegram.commands.base import (
+    CommandContext,
+    ConfirmableCommand,
+    InlineButton,
+    TelegramMessage,
+    _button_rows,
+    _confirmation_buttons_enabled,
+    effective_project_name_for_chat,
+    format_usage,
+)
+from app.telegram.confirmations import PendingConfirmation
+
+FIX_SOURCE_AWAIT_ACTION = "fix_source_await_instruction"
+FIX_COMMIT_PENDING_ACTION = "fix_commit"
+FIX_SOURCE_PENDING_ACTION = "fix_source"
+
+
+def _fix_job_button_label(job: Job) -> str:
+    short_hash = (job.commit_hash or "")[:8]
+    branch = job.branch or "-"
+    return f"{job.id} ({branch}) [{short_hash}]"
+
+
+class FixCommand(ConfirmableCommand):
+    name = "/fix"
+    menu_text = "Choose what to fix."
+    description = "Re-do the commit or source of a previous job"
+
+    _MAX_CANDIDATES = 8
+
+    def execute(self, message: TelegramMessage, ctx: CommandContext) -> str:
+        tokens = message.text.strip().split()
+        if ctx.job_manager is None:
+            return "Fix feature is not available."
+        if len(tokens) == 1:
+            return "Choose what to fix."
+        if len(tokens) == 2:
+            kind = tokens[1].lower()
+            if kind not in {"commit", "source"}:
+                return format_usage("/fix", "/fix commit", "/fix source")
+            candidates = self._list_candidates(message, ctx)
+            if not candidates:
+                return "No job is available to fix."
+            return "Choose a job to fix."
+        if len(tokens) >= 3:
+            kind = tokens[1].lower()
+            if kind not in {"commit", "source"}:
+                return format_usage("/fix", "/fix commit", "/fix source")
+            job_id = tokens[2].strip()
+            project_name = effective_project_name_for_chat(ctx, message.chat_id)
+            if not project_name:
+                return "No project is registered."
+            target_job = ctx.job_store.get(job_id)
+            if target_job is None or not ctx.job_manager.is_fix_candidate(
+                target_job, project_name, message.chat_id
+            ):
+                return f"Job cannot be used as a fix target: {job_id}"
+            if kind == "commit":
+                return self._start_commit_fix(message, ctx, target_job)
+            return self._start_source_fix(message, ctx, target_job)
+        return format_usage("/fix", "/fix commit", "/fix source")
+
+    def _start_commit_fix(
+        self, message: TelegramMessage, ctx: CommandContext, target_job: Job
+    ) -> str:
+        assert ctx.job_manager is not None
+        prepared_message = ctx.job_manager.build_fix_commit_preview(target_job)
+        ctx.confirmation_store.set(
+            effective_project_name_for_chat(ctx, message.chat_id),
+            message.chat_id,
+            PendingConfirmation(
+                command_name=self.name,
+                action=FIX_COMMIT_PENDING_ACTION,
+                target_job_id=target_job.id,
+                prepared_payload=prepared_message,
+            ),
+        )
+        lines = [
+            f"Commit message preview (Job {target_job.id}, branch {target_job.branch})",
+            "",
+            prepared_message,
+            "",
+            "Send y/Y to apply, or n/N to cancel (or use buttons).",
+        ]
+        return "\n".join(lines)
+
+    def _start_source_fix(
+        self, message: TelegramMessage, ctx: CommandContext, target_job: Job
+    ) -> str:
+        ctx.confirmation_store.set(
+            effective_project_name_for_chat(ctx, message.chat_id),
+            message.chat_id,
+            PendingConfirmation(
+                command_name=self.name,
+                action=FIX_SOURCE_AWAIT_ACTION,
+                target_job_id=target_job.id,
+            ),
+        )
+        return (
+            f"Send the fix instruction for Job {target_job.id}. "
+            "The next message will be used as the instruction."
+        )
+
+    def confirm(
+        self,
+        message: TelegramMessage,
+        ctx: CommandContext,
+        pending: PendingConfirmation,
+    ) -> str:
+        if pending.action == FIX_COMMIT_PENDING_ACTION:
+            return self._confirm_commit(message, ctx, pending)
+        if pending.action == FIX_SOURCE_PENDING_ACTION:
+            return self._confirm_source(message, ctx, pending)
+        return "Could not process the pending confirmation."
+
+    def _confirm_commit(
+        self,
+        message: TelegramMessage,
+        ctx: CommandContext,
+        pending: PendingConfirmation,
+    ) -> str:
+        if message.text.strip() not in {"y", "Y"}:
+            return "Cancelled the commit message fix."
+        if ctx.job_manager is None or not pending.target_job_id or not pending.prepared_payload:
+            return "Could not process the pending confirmation."
+        target_job = ctx.job_store.get(pending.target_job_id)
+        project_name = effective_project_name_for_chat(ctx, message.chat_id)
+        if target_job is None or not project_name or not ctx.job_manager.is_fix_candidate(
+            target_job, project_name, message.chat_id
+        ):
+            return "Fix target job is no longer available."
+        request = JobRequest(
+            project=project_name,
+            model=target_job.request.model,
+            model_id=target_job.request.model_id,
+            instruction=target_job.request.instruction,
+            mode=JobMode.AGENT_FIX,
+            fix_kind=FixKind.COMMIT,
+            parent_job_id=target_job.id,
+            branch=target_job.branch,
+            chat_id=message.chat_id,
+            requested_by=message.user_id,
+        )
+        result_job = ctx.job_manager.execute_fix_job(
+            request, prepared_message=pending.prepared_payload
+        )
+        if result_job.status.value == "succeeded":
+            return (
+                f"Commit message updated.\n"
+                f"- Job: {result_job.id}\n"
+                f"- Branch: {result_job.branch}\n"
+                f"- New commit: {result_job.commit_hash}"
+            )
+        return f"Commit message fix failed: {result_job.error or 'unknown'}"
+
+    def _confirm_source(
+        self,
+        message: TelegramMessage,
+        ctx: CommandContext,
+        pending: PendingConfirmation,
+    ) -> str:
+        # Source-mode confirmation is routed by the webhook (background task);
+        # see app/telegram/webhook.py for the actual execution.
+        _ = (message, ctx, pending)
+        return "Started the fix job in the background."
+
+    def get_inline_buttons(
+        self,
+        message: TelegramMessage | None = None,
+        ctx: CommandContext | None = None,
+    ) -> list[list[InlineButton]] | None:
+        if message is None or ctx is None:
+            return None
+        tokens = message.text.strip().split()
+        if len(tokens) == 1:
+            return [
+                [
+                    InlineButton("Fix commit", "/fix commit"),
+                    InlineButton("Fix source", "/fix source"),
+                ],
+            ]
+        if len(tokens) == 2:
+            kind = tokens[1].lower()
+            if kind not in {"commit", "source"}:
+                return None
+            candidates = self._list_candidates(message, ctx)
+            if not candidates:
+                return None
+            return _button_rows(
+                [
+                    InlineButton(_fix_job_button_label(job), f"/fix {kind} {job.id}")
+                    for job in candidates
+                ],
+                per_row=1,
+            )
+        if not _confirmation_buttons_enabled(ctx):
+            return None
+        pending = ctx.confirmation_store.get(
+            effective_project_name_for_chat(ctx, message.chat_id),
+            message.chat_id,
+        )
+        if pending is None or pending.command_name != self.name:
+            return None
+        if pending.action != FIX_COMMIT_PENDING_ACTION:
+            return None
+        return [[InlineButton("Yes", "Y"), InlineButton("No", "n")]]
+
+    def _list_candidates(self, message: TelegramMessage, ctx: CommandContext) -> list[Job]:
+        if ctx.job_manager is None:
+            return []
+        project_name = effective_project_name_for_chat(ctx, message.chat_id)
+        if not project_name:
+            return []
+        return ctx.job_manager.list_fix_candidates(
+            project_name, message.chat_id, limit=self._MAX_CANDIDATES
+        )

app/telegram/commands/model.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from app.ai.model_catalog import format_model_selection, get_model_options, is_valid_model_id
+from app.models import ModelName
+from app.telegram.commands.base import (
+    MODEL_USAGE,
+    CommandContext,
+    InlineButton,
+    TelegramCommand,
+    TelegramMessage,
+    _button_rows,
+    effective_model_selection_for_chat,
+    effective_project_name_for_chat,
+    format_usage,
+)
+from app.telegram.i18n import ui_message
+from app.telegram.model_preferences import ModelPreference
+
+
+class ModelCommand(TelegramCommand):
+    name = "/model"
+    menu_text = ui_message("model.menu", "Choose a model.")
+    description = "Show or change this chat's default AI model"
+
+    def execute(self, message: TelegramMessage, ctx: CommandContext) -> str:
+        tokens = message.text.strip().split()
+        project_name = effective_project_name_for_chat(ctx, message.chat_id)
+        current = effective_model_selection_for_chat(ctx, message.chat_id, project_name)
+        if len(tokens) == 1:
+            return ui_message(
+                "model.settings",
+                "Model settings\n\n- Current default model: {selection}",
+                selection=format_model_selection(current.provider, current.model_id),
+            )
+        if len(tokens) == 2 and tokens[1] in {model.value for model in ModelName}:
+            selected = ModelName(tokens[1])
+            ctx.model_preferences.set(project_name, message.chat_id, selected)
+            return ui_message(
+                "model.provider_selected",
+                "Model provider selected.\n\n- Default model: {provider}\n- Choose a specific model.",
+                provider=selected.value,
+            )
+        if len(tokens) == 3 and tokens[1] in {model.value for model in ModelName}:
+            selected = ModelName(tokens[1])
+            model_id = tokens[2]
+            if not is_valid_model_id(selected, model_id):
+                usage = format_usage(
+                    "/model",
+                    f"/model {MODEL_USAGE}",
+                    f"/model {MODEL_USAGE} <model_id>",
+                )
+                return ui_message(
+                    "model.unknown_specific",
+                    "Unknown specific model: {model_id}\n\n{usage}",
+                    model_id=model_id,
+                    usage=usage,
+                )
+            ctx.model_preferences.set_selection(
+                project_name,
+                message.chat_id,
+                ModelPreference(selected, model_id),
+            )
+            return ui_message(
+                "model.updated",
+                "Model setting updated.\n\n- Default model: {selection}",
+                selection=format_model_selection(selected, model_id),
+            )
+        return format_usage("/model", f"/model {MODEL_USAGE}", f"/model {MODEL_USAGE} <model_id>")
+
+    def get_inline_buttons(
+        self,
+        message: TelegramMessage | None = None,
+        ctx: CommandContext | None = None,
+    ) -> list[list[InlineButton]] | None:
+        tokens = message.text.strip().split() if message is not None else []
+        if len(tokens) <= 1:
+            return [
+                [
+                    InlineButton("claude", "/model claude"),
+                    InlineButton("codex", "/model codex"),
+                    InlineButton("gemini", "/model gemini"),
+                ]
+            ]
+        if len(tokens) == 2 and tokens[1] in {model.value for model in ModelName}:
+            provider = ModelName(tokens[1])
+            return _button_rows(
+                [
+                    InlineButton(option.label, f"/model {provider.value} {option.value}")
+                    for option in get_model_options(provider)
+                ],
+                per_row=1,
+            )
+        return None