remote-coder 0.4.1__py3-none-any.whl

app/config.py

@@ -0,0 +1,130 @@
+import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Self
+
+from pydantic import Field, SecretStr, field_validator, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from app.models import CodexSandboxMode, ModelName
+
+
+def remote_coder_home() -> Path:
+    """Stable per-user config/state home so the CLI works from any directory.
+
+    Overridable with REMOTE_CODER_HOME; defaults to ~/.remote-coder. Holds the
+    global `.env` written by `remote-coder init`.
+    """
+    raw = os.environ.get("REMOTE_CODER_HOME", "").strip()
+    if raw:
+        return Path(raw).expanduser()
+    return Path.home() / ".remote-coder"
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    telegram_bot_token: SecretStr | None = Field(
+        default=None,
+        description=(
+            "Optional seed only: written into projects.json when the registry file is missing "
+            "or lists no projects. Runtime bots use per-project bot_token in the registry."
+        ),
+    )
+    telegram_allowed_chat_ids: list[int] = Field(
+        default_factory=list,
+        description="Optional seed only: initial allowed_chat_ids for the seeded default_project record.",
+    )
+    telegram_allowed_user_ids: list[int] = Field(
+        default_factory=list,
+        description="Optional seed only: initial allowed_user_ids for the seeded default_project record.",
+    )
+    telegram_webhook_secret: SecretStr | None = Field(
+        default=None,
+        description="Optional seed only: initial webhook_secret for the seeded default_project record.",
+    )
+    telegram_webhook_public_base_url: str | None = Field(
+        default=None,
+        description=(
+            "Runtime public HTTPS base URL used to refresh per-project Telegram webhooks "
+            "after project create/update in the admin UI."
+        ),
+    )
+
+    default_model: ModelName = ModelName.CLAUDE
+    default_project: str = "remote-coder"
+    project_root: Path = Field(default_factory=remote_coder_home)
+    worktree_base_dir: Path = Field(default_factory=lambda: remote_coder_home() / "worktrees")
+    job_timeout_seconds: int = 1800
+    keep_worktree_on_success: bool = True
+    projects_config_path: Path | None = None
+    git_remote_name: str = "origin"
+
+    # 프로젝트+채팅별 대화 기억(SQLite). 미설정 시 PROJECT_ROOT/.remote-coder/conversations.sqlite3
+    conversation_db_path: Path | None = None
+    # 작업 메타데이터(SQLite). 미설정 시 PROJECT_ROOT/.remote-coder/jobs.sqlite3
+    job_db_path: Path | None = None
+    conversation_recent_limit: int = 10
+
+    # Codex `codex exec` 샌드박스. 기본 workspace-write (워크트리 내 파일 수정 허용). read-only는 편집 불가.
+    codex_sandbox: CodexSandboxMode = CodexSandboxMode.WORKSPACE_WRITE
+
+    @model_validator(mode="after")
+    def _normalize_telegram_seed_fields(self) -> Self:
+        if self.telegram_bot_token is not None:
+            if not self.telegram_bot_token.get_secret_value().strip():
+                self.telegram_bot_token = None
+        if self.telegram_webhook_secret is not None:
+            if not self.telegram_webhook_secret.get_secret_value().strip():
+                self.telegram_webhook_secret = None
+        if self.telegram_webhook_public_base_url is not None:
+            base = self.telegram_webhook_public_base_url.strip().rstrip("/")
+            self.telegram_webhook_public_base_url = base or None
+        return self
+
+    @model_validator(mode="after")
+    def _default_conversation_db_path(self) -> Self:
+        if self.conversation_db_path is None:
+            self.conversation_db_path = (self.project_root / ".remote-coder" / "conversations.sqlite3").resolve()
+        return self
+
+    @model_validator(mode="after")
+    def _default_job_db_path(self) -> Self:
+        if self.job_db_path is None:
+            self.job_db_path = (self.project_root / ".remote-coder" / "jobs.sqlite3").resolve()
+        return self
+
+    @field_validator("telegram_allowed_chat_ids", mode="before")
+    @classmethod
+    def parse_allowed_chat_ids(cls, value: object) -> list[int]:
+        if value in (None, ""):
+            return []
+        if isinstance(value, list):
+            return [int(v) for v in value]
+        if isinstance(value, (int, float)):
+            return [int(value)]
+        if isinstance(value, str):
+            parsed = [item.strip() for item in value.split(",") if item.strip()]
+            return [int(v) for v in parsed]
+        raise ValueError("TELEGRAM_ALLOWED_CHAT_IDS must be list, int, or comma-separated string")
+
+    @field_validator("telegram_allowed_user_ids", mode="before")
+    @classmethod
+    def parse_allowed_user_ids(cls, value: object) -> list[int]:
+        if value in (None, ""):
+            return []
+        if isinstance(value, list):
+            return [int(v) for v in value]
+        if isinstance(value, (int, float)):
+            return [int(value)]
+        if isinstance(value, str):
+            parsed = [item.strip() for item in value.split(",") if item.strip()]
+            return [int(v) for v in parsed]
+        raise ValueError("TELEGRAM_ALLOWED_USER_IDS must be list, int, or comma-separated string")
+
+
+@lru_cache
+def get_settings() -> Settings:
+    home = remote_coder_home()
+    # cwd ".env" overrides the global home file so in-repo development keeps working.
+    return Settings(_env_file=(home / ".env", Path(".env")))

app/git/ai_commit.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import subprocess
+import tempfile
+
+from app.models import ModelName
+from app.monitoring.events import EventLogger
+
+_log = EventLogger("app.git.ai_commit", "git.commit")
+
+
+class AiCommitBodyGenerator:
+    _PROMPT = (
+        "You are writing a git commit message.\n"
+        "First, output one line: \"title: <concise summary under 72 chars>\"\n"
+        "Then output 2-3 bullet points describing what was changed.\n"
+        "Focus on WHAT changed, not how.\n\n"
+        "Do not copy the raw user request into the title.\n"
+        "User request: {instruction}\n"
+        "Changed files: {files}\n\n"
+        "Output format (exactly):\n"
+        "title: <title here>\n"
+        "- <bullet 1>\n"
+        "- <bullet 2>"
+    )
+
+    def generate(
+        self,
+        instruction: str,
+        changed_files: list[str],
+        model_name: ModelName = ModelName.CLAUDE,
+        timeout: int = 30,
+    ) -> tuple[str | None, str | None]:
+        prompt = self._PROMPT.format(
+            instruction=instruction.strip(),
+            files=", ".join(changed_files) if changed_files else "(none)",
+        )
+        argv = self._build_argv(model_name, prompt)
+        try:
+            with tempfile.TemporaryDirectory() as tmpdir:
+                result = subprocess.run(
+                    argv,
+                    capture_output=True,
+                    text=True,
+                    timeout=timeout,
+                    cwd=tmpdir,
+                    check=False,
+                    shell=False,
+                )
+        except (subprocess.TimeoutExpired, FileNotFoundError) as exc:
+            _log.warning("ai commit generation failed model=%s: %s", model_name.value, exc)
+            return None, None
+
+        if result.returncode != 0 or not result.stdout.strip():
+            _log.warning(
+                "ai commit generation failed model=%s exit=%d",
+                model_name.value,
+                result.returncode,
+            )
+            return None, None
+
+        return self._parse_output(result.stdout)
+
+    @staticmethod
+    def _build_argv(model_name: ModelName, prompt: str) -> list[str]:
+        argv_by_model: dict[ModelName, list[str]] = {
+            ModelName.CLAUDE: ["claude", "-p", prompt, "--dangerously-skip-permissions"],
+            ModelName.CODEX: ["codex", "exec", "--sandbox", "read-only", prompt],
+            ModelName.GEMINI: ["gemini", "-p", prompt],
+        }
+        argv = argv_by_model.get(model_name)
+        if argv is None:
+            raise ValueError(f"Unsupported model for commit body generation: {model_name}")
+        return argv
+
+    @staticmethod
+    def _parse_output(stdout: str) -> tuple[str | None, str | None]:
+        ai_title: str | None = None
+        bullet_lines: list[str] = []
+        for line in stdout.strip().splitlines():
+            stripped = line.strip()
+            if ai_title is None and stripped.startswith("title: "):
+                ai_title = stripped[len("title: "):].strip()
+            elif stripped.startswith("- "):
+                bullet_lines.append(stripped)
+
+        ai_body = "\n".join(bullet_lines) if bullet_lines else None
+        return ai_title or None, ai_body

app/git/branch_naming.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import re
+from abc import ABC, abstractmethod
+from datetime import UTC, datetime
+
+
+class BranchNamingStrategy(ABC):
+    @abstractmethod
+    def make_branch_name(self, instruction: str) -> str:
+        raise NotImplementedError
+
+
+class TimestampSlugStrategy(BranchNamingStrategy):
+    def make_branch_name(self, instruction: str) -> str:
+        slug = re.sub(r"[^a-zA-Z0-9]+", "-", instruction.strip().lower()).strip("-")
+        slug = slug or "task"
+        if len(slug) > 30:
+            slug = slug[:30].rstrip("-")
+        ts = datetime.now(UTC).strftime("%Y%m%d-%H%M%S")
+        return f"remote-{slug}-{ts}"

app/git/commit_message.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import re
+
+
+class CommitMessageFormatter:
+    _OPTION_PATTERN = re.compile(
+        r"\b(?:model|branch|project)\s*:\s*\S+|\bno\s+commit\b",
+        flags=re.IGNORECASE,
+    )
+    _SPEAKER_PREFIX_PATTERN = re.compile(r"^user\s*:\s*", flags=re.IGNORECASE)
+    _PARENTHETICAL_EXAMPLE_PATTERN = re.compile(r"\(ex>?.*?\)", flags=re.IGNORECASE)
+    _WHITESPACE_PATTERN = re.compile(r"\s+")
+    _REQUEST_MARKERS = (
+        "please",
+        "can you",
+        "could you",
+        "would you",
+    )
+    _FIX_KEYWORDS = (
+        "bug",
+        "error",
+        "fix",
+        "issue",
+        "patch",
+        "repair",
+        "resolve",
+    )
+    _REFACTOR_KEYWORDS = (
+        "cleanup",
+        "extract",
+        "refactor",
+        "rename",
+        "restructure",
+        "simplify",
+    )
+    _CHORE_KEYWORDS = (
+        "build",
+        "chore",
+        "ci",
+        "config",
+        "dependency",
+        "deps",
+        "docs",
+        "documentation",
+        "readme",
+        "test",
+    )
+
+    @classmethod
+    def format(
+        cls,
+        job_id: str,
+        instruction: str,
+        changed_files: list[str],
+        ai_body: str | None = None,
+        ai_title: str | None = None,
+    ) -> str:
+        commit_type = cls._infer_type(instruction, changed_files)
+        title = cls._safe_ai_title(ai_title) or cls._build_title(
+            instruction,
+            changed_files,
+            commit_type,
+        )
+        body = cls._safe_ai_body(ai_body)
+        if body is None:
+            bullets = cls._build_bullets(commit_type, changed_files)
+            body = "\n".join(f"- {bullet}" for bullet in bullets)
+        return f"{commit_type}: {title}\n\n{body}\n\ncommitted by remote-coder: {job_id}"
+
+    @classmethod
+    def _infer_type(cls, instruction: str, changed_files: list[str]) -> str:
+        lowered = instruction.casefold()
+        if any(keyword in lowered for keyword in cls._FIX_KEYWORDS):
+            return "fix"
+        if changed_files and all(cls._is_chore_path(path) for path in changed_files):
+            return "chore"
+        if any(keyword in lowered for keyword in cls._REFACTOR_KEYWORDS):
+            return "refactor"
+        if any(keyword in lowered for keyword in cls._CHORE_KEYWORDS):
+            return "chore"
+        return "feat"
+
+    @classmethod
+    def _build_title(cls, instruction: str, changed_files: list[str], commit_type: str) -> str:
+        summary = cls._instruction_summary(instruction)
+        if summary:
+            return summary
+
+        if any(path.startswith("app/monitoring/") for path in changed_files):
+            return "update monitoring behavior"
+        if any(path.startswith("app/telegram/") for path in changed_files):
+            return "update telegram behavior"
+        if any(path.startswith("app/admin/") for path in changed_files):
+            return "update admin behavior"
+        if any(path.startswith("app/git/") for path in changed_files):
+            return "update git workflow"
+        if any(path.startswith("docs/") or path == "README.md" for path in changed_files):
+            return "update project documentation"
+        scoped_title = cls._build_scoped_title(commit_type, changed_files)
+        if scoped_title:
+            return scoped_title
+        return "update requested behavior"
+
+    @classmethod
+    def _instruction_summary(cls, instruction: str, max_length: int = 72) -> str:
+        line = cls._first_meaningful_instruction_line(instruction)
+        if not line:
+            return ""
+
+        line = cls._SPEAKER_PREFIX_PATTERN.sub("", line)
+        line = cls._OPTION_PATTERN.sub("", line)
+        line = cls._PARENTHETICAL_EXAMPLE_PATTERN.sub("", line)
+        line = cls._WHITESPACE_PATTERN.sub(" ", line).strip()
+        line = line.strip().strip("-:;,.!?").strip("\"'`")
+        if not line:
+            return ""
+        if not cls._is_ascii_text(line):
+            return ""
+
+        if cls._mentions_monitor_model_metrics(line):
+            return "show current model and token usage in monitor model"
+        if cls._looks_like_raw_request(line):
+            return ""
+        return cls._truncate_at_word(cls._lowercase_initial_ascii(line), max_length)
+
+    @classmethod
+    def _safe_ai_title(
+        cls,
+        ai_title: str | None,
+        max_length: int = 72,
+    ) -> str | None:
+        if ai_title is None:
+            return None
+        title = cls._WHITESPACE_PATTERN.sub(" ", ai_title).strip()
+        title = title.strip().strip("-:;,.!?").strip("\"'`")
+        if not title or len(title) > max_length:
+            return None
+        if not cls._is_ascii_text(title):
+            return None
+        if cls._looks_like_raw_request(title):
+            return None
+        return cls._lowercase_initial_ascii(title)
+
+    @classmethod
+    def _safe_ai_body(cls, ai_body: str | None) -> str | None:
+        if ai_body is None:
+            return None
+        lines = [line.rstrip() for line in ai_body.strip().splitlines() if line.strip()]
+        if not lines:
+            return None
+        body = "\n".join(lines)
+        if not cls._is_ascii_text(body):
+            return None
+        return body
+
+    @classmethod
+    def _looks_like_raw_request(cls, text: str) -> bool:
+        lowered = text.casefold()
+        return any(marker in lowered for marker in cls._REQUEST_MARKERS)
+
+    @classmethod
+    def _build_scoped_title(cls, commit_type: str, changed_files: list[str]) -> str:
+        scope = cls._common_source_scope(changed_files)
+        if not scope:
+            return ""
+        verb = {
+            "fix": "fix",
+            "refactor": "refactor",
+            "chore": "maintain",
+        }.get(commit_type, "update")
+        return f"{verb} {scope}"
+
+    @staticmethod
+    def _common_source_scope(changed_files: list[str]) -> str:
+        source_files = [
+            path
+            for path in changed_files
+            if "/" in path and not path.startswith(("tests/", "docs/", "."))
+        ]
+        if not source_files:
+            return ""
+
+        split_paths = [path.split("/")[:-1] for path in source_files]
+        common: list[str] = []
+        for parts in zip(*split_paths):
+            if len(set(parts)) != 1:
+                break
+            common.append(parts[0])
+        if common:
+            return f"{'/'.join(common)} source"
+        return f"{source_files[0].split('/', 1)[0]} source"
+
+    _CURRENT_REQUEST_MARKERS = (
+        "[Current request]",
+        "[/current request]",
+    )
+    _CONTEXT_NOISE_PREFIXES = (
+        "job_id=",
+        "message_id=",
+    )
+
+    @classmethod
+    def _first_meaningful_instruction_line(cls, instruction: str) -> str:
+        skip_depth = 0
+        for raw_line in instruction.splitlines():
+            line = raw_line.strip()
+            if not line:
+                continue
+            if line in cls._CURRENT_REQUEST_MARKERS:
+                continue
+            if line.startswith("[/") and line.endswith("]"):
+                skip_depth = max(0, skip_depth - 1)
+                continue
+            if line.startswith("[") and line.endswith("]"):
+                skip_depth += 1
+                continue
+            if skip_depth > 0:
+                continue
+            if any(line.startswith(prefix) for prefix in cls._CONTEXT_NOISE_PREFIXES):
+                continue
+            return line
+        return ""
+
+    @staticmethod
+    def _mentions_monitor_model_metrics(text: str) -> bool:
+        lowered = text.casefold()
+        return "monitor model" in lowered and "token" in lowered
+
+    @staticmethod
+    def _is_ascii_text(text: str) -> bool:
+        return text.isascii()
+
+    @staticmethod
+    def _truncate_at_word(text: str, max_length: int) -> str:
+        if len(text) <= max_length:
+            return text
+        clipped = text[: max_length + 1].rsplit(" ", 1)[0].strip()
+        if not clipped:
+            clipped = text[:max_length].strip()
+        return clipped.rstrip(".,;:")
+
+    @staticmethod
+    def _lowercase_initial_ascii(text: str) -> str:
+        if len(text) >= 2 and "A" <= text[0] <= "Z" and not ("A" <= text[1] <= "Z"):
+            return text[0].lower() + text[1:]
+        return text
+
+    @classmethod
+    def _build_bullets(cls, commit_type: str, changed_files: list[str]) -> list[str]:
+        first_bullets = {
+            "fix": "AI agent fixed the requested behavior",
+            "refactor": "AI agent refactored the requested area",
+            "chore": "AI agent maintained project assets",
+            "feat": "AI agent implemented the requested change",
+        }
+        bullets: list[str] = [first_bullets.get(commit_type, "AI agent implemented the requested change")]
+
+        if any(path.startswith("tests/") for path in changed_files):
+            bullets.append("AI agent updated automated coverage where applicable")
+        elif any(cls._is_doc_path(path) for path in changed_files):
+            bullets.append("AI agent refreshed related documentation where applicable")
+        return bullets[:2]
+
+    @staticmethod
+    def _is_doc_path(path: str) -> bool:
+        return path == "README.md" or path.startswith("docs/")
+
+    @classmethod
+    def _is_chore_path(cls, path: str) -> bool:
+        return (
+            cls._is_doc_path(path)
+            or path.startswith("tests/")
+            or path.endswith(".yml")
+            or path.endswith(".yaml")
+            or path.endswith(".toml")
+            or path.endswith(".ini")
+            or path.endswith(".cfg")
+        )