takopi-slack-plugin 0.0.15__py3-none-any.whl

takopi_slack_plugin/engine.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable
+
+import anyio
+
+from takopi.api import (
+    ConfigError,
+    ExecBridgeConfig,
+    IncomingMessage as RunnerIncomingMessage,
+    MessageRef,
+    RenderedMessage,
+    RunContext,
+    RunnerUnavailableError,
+    RunningTasks,
+    SendOptions,
+    TransportRuntime,
+    bind_run_context,
+    clear_context,
+    handle_message,
+    reset_run_base_dir,
+    set_run_base_dir,
+)
+from takopi.runners.run_options import EngineRunOptions, apply_run_options
+
+
+async def send_plain(
+    exec_cfg: ExecBridgeConfig,
+    *,
+    channel_id: str,
+    user_msg_id: str,
+    thread_id: str | None,
+    text: str,
+    notify: bool = True,
+) -> MessageRef | None:
+    reply_ref = MessageRef(
+        channel_id=channel_id,
+        message_id=user_msg_id,
+        thread_id=thread_id,
+    )
+    return await exec_cfg.transport.send(
+        channel_id=channel_id,
+        message=RenderedMessage(text=text),
+        options=SendOptions(reply_to=reply_ref, notify=notify, thread_id=thread_id),
+    )
+
+
+async def run_engine(
+    *,
+    exec_cfg: ExecBridgeConfig,
+    runtime: TransportRuntime,
+    running_tasks: RunningTasks,
+    channel_id: str,
+    user_msg_id: str,
+    text: str,
+    resume_token,
+    context: RunContext | None,
+    engine_override,
+    thread_id: str | None,
+    on_thread_known: Callable[[Any, anyio.Event], Awaitable[None]] | None = None,
+    run_options: EngineRunOptions | None = None,
+) -> None:
+    try:
+        try:
+            entry = runtime.resolve_runner(
+                resume_token=resume_token,
+                engine_override=engine_override,
+            )
+        except RunnerUnavailableError as exc:
+            await send_plain(
+                exec_cfg,
+                channel_id=channel_id,
+                user_msg_id=user_msg_id,
+                thread_id=thread_id,
+                text=f"error:\n{exc}",
+                notify=False,
+            )
+            return
+
+        runner = entry.runner
+        if not entry.available:
+            reason = entry.issue or "engine unavailable"
+            await send_plain(
+                exec_cfg,
+                channel_id=channel_id,
+                user_msg_id=user_msg_id,
+                thread_id=thread_id,
+                text=f"error:\n{reason}",
+                notify=False,
+            )
+            return
+
+        try:
+            cwd = runtime.resolve_run_cwd(context)
+        except ConfigError as exc:
+            await send_plain(
+                exec_cfg,
+                channel_id=channel_id,
+                user_msg_id=user_msg_id,
+                thread_id=thread_id,
+                text=f"error:\n{exc}",
+                notify=False,
+            )
+            return
+
+        run_base_token = set_run_base_dir(cwd)
+        try:
+            run_fields: dict[str, Any] = {
+                "channel_id": channel_id,
+                "user_msg_id": user_msg_id,
+                "engine": runner.engine,
+                "resume": resume_token.value if resume_token else None,
+            }
+            if context is not None:
+                run_fields["project"] = context.project
+                run_fields["branch"] = context.branch
+            if cwd is not None:
+                run_fields["cwd"] = str(cwd)
+            bind_run_context(**run_fields)
+            context_line = runtime.format_context_line(context)
+            incoming = RunnerIncomingMessage(
+                channel_id=channel_id,
+                message_id=user_msg_id,
+                text=text,
+                thread_id=thread_id,
+            )
+            with apply_run_options(run_options):
+                await handle_message(
+                    exec_cfg,
+                    runner=runner,
+                    incoming=incoming,
+                    resume_token=resume_token,
+                    context=context,
+                    context_line=context_line,
+                    strip_resume_line=runtime.is_resume_line,
+                    running_tasks=running_tasks,
+                    on_thread_known=on_thread_known,
+                )
+        finally:
+            reset_run_base_dir(run_base_token)
+    finally:
+        clear_context()

takopi_slack_plugin/onboarding.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import questionary
+
+from takopi.api import ConfigError, HOME_CONFIG_PATH, read_config, write_config
+
+
+async def interactive_setup(*, force: bool) -> bool:
+    _ = force
+    config_path = HOME_CONFIG_PATH
+    try:
+        config = read_config(config_path)
+    except ConfigError:
+        config = {}
+
+    bot_token = questionary.password("Slack bot token").ask()
+    if not bot_token:
+        return False
+    app_token = questionary.password("Slack app token (xapp-)").ask()
+    if not app_token:
+        return False
+    channel_id = questionary.text("Slack channel ID").ask()
+    if not channel_id:
+        return False
+    transports = _ensure_table(config, "transports", config_path=config_path)
+    slack = _ensure_table(
+        transports,
+        "slack",
+        config_path=config_path,
+        label="transports.slack",
+    )
+    slack["bot_token"] = str(bot_token).strip()
+    slack["app_token"] = str(app_token).strip()
+    slack["channel_id"] = str(channel_id).strip()
+    config["transport"] = "slack"
+    write_config(config, config_path)
+    return True
+
+
+def _ensure_table(
+    config: dict[str, Any],
+    key: str,
+    *,
+    config_path: Path,
+    label: str | None = None,
+) -> dict[str, Any]:
+    value = config.get(key)
+    if value is None:
+        table: dict[str, Any] = {}
+        config[key] = table
+        return table
+    if not isinstance(value, dict):
+        name = label or key
+        raise ConfigError(f"Invalid `{name}` in {config_path}; expected a table.")
+    return value

takopi_slack_plugin/outbox.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+import anyio
+
+__all__ = [
+    "DELETE_PRIORITY",
+    "EDIT_PRIORITY",
+    "SEND_PRIORITY",
+    "OutboxOp",
+    "SlackOutbox",
+]
+
+SEND_PRIORITY = 0
+DELETE_PRIORITY = 1
+EDIT_PRIORITY = 2
+
+DEFAULT_CHANNEL_INTERVAL = 0.3
+
+
+@dataclass(slots=True)
+class OutboxOp:
+    execute: callable
+    priority: int
+    queued_at: float
+    channel_id: str | None
+    label: str | None = None
+    done: anyio.Event = field(default_factory=anyio.Event)
+    result: Any = None
+
+    def set_result(self, result: Any) -> None:
+        if self.done.is_set():
+            return
+        self.result = result
+        self.done.set()
+
+
+class SlackOutbox:
+    def __init__(
+        self,
+        *,
+        interval_for_channel: callable | None = None,
+        clock: callable = time.monotonic,
+        sleep: callable = anyio.sleep,
+        on_error: callable | None = None,
+        on_outbox_error: callable | None = None,
+    ) -> None:
+        self._interval_for_channel = interval_for_channel or (
+            lambda _: DEFAULT_CHANNEL_INTERVAL
+        )
+        self._clock = clock
+        self._sleep = sleep
+        self._on_error = on_error
+        self._on_outbox_error = on_outbox_error
+        self._pending: dict[object, OutboxOp] = {}
+        self._cond = anyio.Condition()
+        self._start_lock = anyio.Lock()
+        self._closed = False
+        self._tg: anyio.abc.TaskGroup | None = None
+        self._next_at = 0.0
+
+    async def ensure_worker(self) -> None:
+        async with self._start_lock:
+            if self._tg is not None or self._closed:
+                return
+            self._tg = await anyio.create_task_group().__aenter__()
+            self._tg.start_soon(self._run)
+
+    async def enqueue(self, *, key: object, op: OutboxOp, wait: bool = True) -> Any:
+        await self.ensure_worker()
+        async with self._cond:
+            if self._closed:
+                op.set_result(None)
+                return op.result
+            previous = self._pending.get(key)
+            if previous is not None:
+                op.queued_at = previous.queued_at
+                previous.set_result(None)
+            self._pending[key] = op
+            self._cond.notify()
+        if not wait:
+            return None
+        await op.done.wait()
+        return op.result
+
+    async def drop_pending(self, *, key: object) -> None:
+        async with self._cond:
+            pending = self._pending.pop(key, None)
+            if pending is not None:
+                pending.set_result(None)
+            self._cond.notify()
+
+    async def close(self) -> None:
+        async with self._cond:
+            self._closed = True
+            self._fail_pending()
+            self._cond.notify_all()
+        if self._tg is not None:
+            await self._tg.__aexit__(None, None, None)
+            self._tg = None
+
+    def _fail_pending(self) -> None:
+        for pending in list(self._pending.values()):
+            pending.set_result(None)
+        self._pending.clear()
+
+    def _pick_locked(self) -> tuple[object, OutboxOp] | None:
+        if not self._pending:
+            return None
+        return min(
+            self._pending.items(),
+            key=lambda item: (item[1].priority, item[1].queued_at),
+        )
+
+    async def _execute_op(self, op: OutboxOp) -> Any:
+        try:
+            return await op.execute()
+        except Exception as exc:  # noqa: BLE001
+            if self._on_error is not None:
+                self._on_error(op, exc)
+            return None
+
+    async def _sleep_until(self, deadline: float) -> None:
+        delay = deadline - self._clock()
+        if delay > 0:
+            await self._sleep(delay)
+
+    async def _run(self) -> None:
+        cancel_exc = anyio.get_cancelled_exc_class()
+        try:
+            while True:
+                async with self._cond:
+                    while not self._pending and not self._closed:
+                        await self._cond.wait()
+                    if self._closed and not self._pending:
+                        return
+
+                if self._clock() < self._next_at:
+                    await self._sleep_until(self._next_at)
+                    continue
+
+                async with self._cond:
+                    if self._closed and not self._pending:
+                        return
+                    picked = self._pick_locked()
+                    if picked is None:
+                        continue
+                    key, op = picked
+                    self._pending.pop(key, None)
+
+                interval = self._interval_for_channel(op.channel_id)
+                if interval:
+                    self._next_at = max(self._next_at, self._clock()) + interval
+                result = await self._execute_op(op)
+                op.set_result(result)
+        except cancel_exc:
+            return
+        except Exception as exc:  # noqa: BLE001
+            self._fail_pending()
+            if self._on_outbox_error is not None:
+                self._on_outbox_error(exc)
+            return

takopi_slack_plugin/overrides.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+REASONING_LEVELS = frozenset({"minimal", "low", "medium", "high", "xhigh"})
+REASONING_ENGINES = frozenset({"codex"})
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedOverrides:
+    model: str | None = None
+    reasoning: str | None = None
+
+
+def supports_reasoning(engine_id: str) -> bool:
+    return engine_id in REASONING_ENGINES
+
+
+def is_valid_reasoning_level(level: str) -> bool:
+    return level in REASONING_LEVELS

takopi_slack_plugin/thread_sessions.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+from pathlib import Path
+import msgspec
+
+from takopi.api import ResumeToken, RunContext, get_logger
+from takopi.telegram.state_store import JsonStateStore
+
+logger = get_logger(__name__)
+
+STATE_VERSION = 1
+STATE_FILENAME = "slack_thread_sessions_state.json"
+
+
+class _ThreadSession(msgspec.Struct, forbid_unknown_fields=False):
+    resumes: dict[str, str] = msgspec.field(default_factory=dict)
+    context: dict[str, str] | None = None
+    model_overrides: dict[str, str] | None = None
+    reasoning_overrides: dict[str, str] | None = None
+    default_engine: str | None = None
+
+
+class _ThreadSessionsState(msgspec.Struct, forbid_unknown_fields=False):
+    version: int
+    threads: dict[str, _ThreadSession] = msgspec.field(default_factory=dict)
+
+
+def resolve_sessions_path(config_path: Path) -> Path:
+    return config_path.with_name(STATE_FILENAME)
+
+
+def _thread_key(channel_id: str, thread_id: str) -> str:
+    return f"{channel_id}:{thread_id}"
+
+
+def _new_state() -> _ThreadSessionsState:
+    return _ThreadSessionsState(version=STATE_VERSION, threads={})
+
+
+class SlackThreadSessionStore(JsonStateStore[_ThreadSessionsState]):
+    def __init__(self, path: Path) -> None:
+        super().__init__(
+            path,
+            version=STATE_VERSION,
+            state_type=_ThreadSessionsState,
+            state_factory=_new_state,
+            log_prefix="slack.thread_sessions",
+            logger=logger,
+        )
+
+    @staticmethod
+    def _thread_key(channel_id: str, thread_id: str) -> str:
+        return _thread_key(channel_id, thread_id)
+
+    def _get_or_create(self, key: str) -> _ThreadSession:
+        session = self._state.threads.get(key)
+        if session is None:
+            session = _ThreadSession()
+            self._state.threads[key] = session
+        return session
+
+    async def get_resume(
+        self, *, channel_id: str, thread_id: str, engine: str
+    ) -> ResumeToken | None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._state.threads.get(key)
+            if session is None:
+                return None
+            value = session.resumes.get(engine)
+            if not value:
+                return None
+            return ResumeToken(engine=engine, value=value)
+
+    async def set_resume(
+        self, *, channel_id: str, thread_id: str, token: ResumeToken
+    ) -> None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._get_or_create(key)
+            session.resumes[token.engine] = token.value
+            self._save_locked()
+
+    async def clear_thread(self, *, channel_id: str, thread_id: str) -> None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            if key not in self._state.threads:
+                return
+            self._state.threads.pop(key, None)
+            self._save_locked()
+
+    async def clear_resumes(self, *, channel_id: str, thread_id: str) -> None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._state.threads.get(key)
+            if session is None:
+                return
+            session.resumes = {}
+            self._save_locked()
+
+    async def get_context(
+        self, *, channel_id: str, thread_id: str
+    ) -> RunContext | None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._state.threads.get(key)
+            if session is None or session.context is None:
+                return None
+            project = session.context.get("project")
+            if not project:
+                return None
+            branch = session.context.get("branch")
+            return RunContext(project=project, branch=branch)
+
+    async def set_context(
+        self,
+        *,
+        channel_id: str,
+        thread_id: str,
+        context: RunContext | None,
+    ) -> None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._get_or_create(key)
+            if context is None:
+                session.context = None
+            else:
+                payload: dict[str, str] = {"project": context.project}
+                if context.branch:
+                    payload["branch"] = context.branch
+                session.context = payload
+            self._save_locked()
+
+    async def get_default_engine(
+        self, *, channel_id: str, thread_id: str
+    ) -> str | None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._state.threads.get(key)
+            if session is None:
+                return None
+            return session.default_engine
+
+    async def get_state(
+        self, *, channel_id: str, thread_id: str
+    ) -> dict[str, object] | None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._state.threads.get(key)
+            if session is None:
+                return None
+            return {
+                "context": dict(session.context) if session.context else None,
+                "default_engine": session.default_engine,
+                "model_overrides": dict(session.model_overrides)
+                if session.model_overrides
+                else None,
+                "reasoning_overrides": dict(session.reasoning_overrides)
+                if session.reasoning_overrides
+                else None,
+                "resumes": dict(session.resumes) if session.resumes else None,
+            }
+
+    async def set_default_engine(
+        self,
+        *,
+        channel_id: str,
+        thread_id: str,
+        engine: str | None,
+    ) -> None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._get_or_create(key)
+            session.default_engine = _normalize_override(engine)
+            self._save_locked()
+
+    async def get_model_override(
+        self, *, channel_id: str, thread_id: str, engine: str
+    ) -> str | None:
+        return await self._get_override(
+            channel_id=channel_id,
+            thread_id=thread_id,
+            engine=engine,
+            field="model_overrides",
+        )
+
+    async def set_model_override(
+        self,
+        *,
+        channel_id: str,
+        thread_id: str,
+        engine: str,
+        model: str | None,
+    ) -> None:
+        await self._set_override(
+            channel_id=channel_id,
+            thread_id=thread_id,
+            engine=engine,
+            value=model,
+            field="model_overrides",
+        )
+
+    async def get_reasoning_override(
+        self, *, channel_id: str, thread_id: str, engine: str
+    ) -> str | None:
+        return await self._get_override(
+            channel_id=channel_id,
+            thread_id=thread_id,
+            engine=engine,
+            field="reasoning_overrides",
+        )
+
+    async def set_reasoning_override(
+        self,
+        *,
+        channel_id: str,
+        thread_id: str,
+        engine: str,
+        level: str | None,
+    ) -> None:
+        await self._set_override(
+            channel_id=channel_id,
+            thread_id=thread_id,
+            engine=engine,
+            value=level,
+            field="reasoning_overrides",
+        )
+
+    async def _get_override(
+        self,
+        *,
+        channel_id: str,
+        thread_id: str,
+        engine: str,
+        field: str,
+    ) -> str | None:
+        key = self._thread_key(channel_id, thread_id)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._state.threads.get(key)
+            if session is None:
+                return None
+            overrides = getattr(session, field)
+            if not isinstance(overrides, dict):
+                return None
+            value = overrides.get(engine)
+            return _normalize_override(value)
+
+    async def _set_override(
+        self,
+        *,
+        channel_id: str,
+        thread_id: str,
+        engine: str,
+        value: str | None,
+        field: str,
+    ) -> None:
+        key = self._thread_key(channel_id, thread_id)
+        normalized = _normalize_override(value)
+        async with self._lock:
+            self._reload_locked_if_needed()
+            session = self._get_or_create(key)
+            overrides = getattr(session, field)
+            if overrides is None or not isinstance(overrides, dict):
+                overrides = {}
+                setattr(session, field, overrides)
+            if normalized is None:
+                overrides.pop(engine, None)
+                if not overrides:
+                    setattr(session, field, None)
+            else:
+                overrides[engine] = normalized
+            self._save_locked()
+
+
+def _normalize_override(value: str | None) -> str | None:
+    if value is None:
+        return None
+    cleaned = value.strip()
+    return cleaned or None