taskboy 0.1.1__py3-none-any.whl

taskboy/llm.py

@@ -0,0 +1,125 @@
+"""small structured model calls used outside agent sessions.
+
+these go through the claude agent sdk (the claude code cli) so billing follows the
+cli's own login — usage credits/subscription — rather than a metered ANTHROPIC_API_KEY.
+"""
+
+import json
+import logging
+import shutil
+import tempfile
+from typing import Any
+
+from taskboy.redact import redactor
+
+logger = logging.getLogger("taskboy.llm")
+
+_DIAGNOSTIC_SNIPPET_LEN = 300
+
+# sdk raises this after already yielding a usable result frame (issue #80)
+_TOLERABLE_ERROR_TEXT = "Claude Code returned an error result: success"
+
+_JSON_FALLBACK_PREAMBLE = "Respond with only a single minified JSON object (no prose, no markdown fences) matching this schema exactly:\n"
+
+
+class _NoFrameObserved(Exception):
+    """the tolerated SDK error (#80) arrived before any usable frame was seen (#93)."""
+
+
+async def structured_call(model_id: str, prompt: str, schema: dict[str, Any]) -> tuple[dict, dict | None]:
+    """one tool-free schema-shaped call; retries once on failure, then raises."""
+    use_output_format = True
+    last_exc: Exception | None = None
+    for attempt in (1, 2):
+        try:
+            return await _structured_call_once(model_id, prompt, schema, use_output_format=use_output_format)
+        except Exception as exc:
+            last_exc = exc
+            if isinstance(exc, _NoFrameObserved):
+                # retrying the identical call fails identically, so the retry drops output_format and parses text
+                use_output_format = False
+            logger.warning("structured_call attempt %s/2 failed (%s): %s", attempt, type(exc).__name__, redactor.redact(str(exc))[:_DIAGNOSTIC_SNIPPET_LEN])
+    assert last_exc is not None
+    raise last_exc
+
+
+async def _structured_call_once(model_id: str, prompt: str, schema: dict[str, Any], *, use_output_format: bool) -> tuple[dict, dict | None]:
+    from claude_agent_sdk import ClaudeAgentOptions, SystemMessage, query
+
+    cwd = tempfile.mkdtemp(prefix="taskboy-llm-")
+    call_prompt = prompt if use_output_format else f"{prompt}\n\n{_JSON_FALLBACK_PREAMBLE}{json.dumps(schema)}"
+    try:
+        options = ClaudeAgentOptions(
+            model=model_id,
+            max_turns=3,  # structured output consumes an extra turn; 1 fails with error_max_turns (phase 0 finding)
+            allowed_tools=[],
+            setting_sources=[],
+            cwd=cwd,
+            output_format={"type": "json_schema", "schema": schema} if use_output_format else None,
+            effort="low",
+        )
+        final = None
+        seen: list[str] = []
+        try:
+            async for message in query(prompt=call_prompt, options=options):
+                seen.append(type(message).__name__)
+                # trailing session_state_changed marker must not clobber the result frame (#80)
+                if isinstance(message, SystemMessage) and message.subtype == "session_state_changed":
+                    continue
+                final = message
+        except Exception as exc:
+            if str(exc) != _TOLERABLE_ERROR_TEXT:
+                raise
+            if final is None:
+                # surface what was actually seen instead of the same undiagnosable message every time
+                diag = f"{exc} (no result frame observed before raise; frames seen: {seen or ['none']})"
+                raise _NoFrameObserved(diag) from exc
+            logger.warning("tolerating SDK 'error result: success' (%s)", _diagnose(final))
+    finally:
+        shutil.rmtree(cwd, ignore_errors=True)  # per-call temp cwd must not accumulate on the host
+    candidate = getattr(final, "structured_output", None)
+    if candidate is None:
+        result = getattr(final, "result", None)
+        candidate = _extract_json(result) if isinstance(result, str) else result
+    if not isinstance(candidate, dict):
+        raise ValueError(f"model returned no structured output ({_diagnose(final)})")
+    return candidate, extract_usage(final)
+
+
+def _diagnose(message: Any) -> str:
+    """attributes a 'no structured output' failure to the terminal message shape instead of a bare traceback."""
+    if message is None:
+        return "type=None subtype=None result=None"
+    msg_type = type(message).__name__
+    subtype = getattr(message, "subtype", None)
+    result = getattr(message, "result", None)
+    snippet = redactor.redact(str(result))[:_DIAGNOSTIC_SNIPPET_LEN] if result is not None else None
+    return f"type={msg_type} subtype={subtype!r} result={snippet!r}"
+
+
+def _extract_json(text: str) -> dict | None:
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    start, end = text.find("{"), text.rfind("}")
+    if start != -1 and end > start:
+        try:
+            return json.loads(text[start : end + 1])
+        except json.JSONDecodeError:
+            return None
+    return None
+
+
+def extract_usage(message) -> dict | None:
+    usage = getattr(message, "usage", None) or {}
+    cost = getattr(message, "total_cost_usd", None)
+    if not usage and cost is None:
+        return None
+    return {
+        "input_tokens": usage.get("input_tokens"),
+        "output_tokens": usage.get("output_tokens"),
+        "cache_read_tokens": usage.get("cache_read_input_tokens"),
+        "cache_write_tokens": usage.get("cache_creation_input_tokens"),
+        "cost_usd": cost,
+    }

taskboy/main.py

@@ -0,0 +1,269 @@
+"""service entrypoint: wire store + orchestrator (+ slack when configured), handle signals, run until stopped."""
+
+import asyncio
+import contextlib
+import logging
+import os
+import signal
+import sys
+import traceback
+from typing import Any
+
+from taskboy import repocache, settings, workspace
+from taskboy.classifier import Classifier, stub_classify
+from taskboy.config import ConfigError, load_config, role_for
+from taskboy.notify import StdoutNotifier
+from taskboy.orchestrator import Orchestrator
+from taskboy.runner import ClaudeRunner, EchoRunner
+from taskboy.store import Store
+
+logger = logging.getLogger("taskboy")
+
+SLACK_CONNECT_TIMEOUT_SECONDS = 60
+
+
+async def serve_slack(handler: Any, store: Store, notifier: Any, connect_timeout: float = SLACK_CONNECT_TIMEOUT_SECONDS) -> None:
+    """slack_sdk's connect() retries forever and never raises, so detect a dead connection via task.done()."""
+    task = asyncio.ensure_future(handler.connect_async())
+    try:
+        await asyncio.wait({task}, timeout=connect_timeout)
+        if not task.done():
+            raise RuntimeError(f"slack socket-mode client did not connect within {connect_timeout}s")
+        await task
+    except asyncio.CancelledError:
+        task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await task
+        raise
+    except Exception as e:
+        logger.exception("slack socket-mode handler failed to start")
+        store.add_error("slack", type(e).__name__, str(e), traceback=traceback.format_exc(), context={"operation": "socket_mode_start"})
+        debug = getattr(notifier, "debug", None)
+        if debug is not None:
+            await debug.system_error("slack", f"socket-mode handler failed to start: {type(e).__name__}: {e}")
+        if not task.done():
+            await task  # connect() retries forever internally -- a late connection shouldn't be cancelled
+
+
+def should_start_review_poller(config, broker) -> bool:
+    review_requests = (config.raw.get("github") or {}).get("review_requests") or {}
+    if config.runner != "claude" or broker is None or not review_requests.get("enabled", False):
+        return False
+    if role_for(config.roles, "github") is None:
+        logger.warning("github review-request polling is enabled but user 'github' has no configured role — poller disabled")
+        return False
+    return True
+
+
+async def amain() -> None:
+    config = load_config(settings.CONFIG_PATH)
+    store = Store(settings.DB_PATH)
+
+    secrets = None
+    if config.slack.enabled or config.runner == "claude" or config.dashboard.enabled:
+        from taskboy.secrets import load_secrets
+
+        secrets = load_secrets()
+        if secrets.claude_oauth_token and not os.environ.get("CLAUDE_CODE_OAUTH_TOKEN"):
+            os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = secrets.claude_oauth_token  # the sdk's cli subprocesses read it from the process env
+
+    notifier: Any  # duck-typed interface, see notify.py
+    handler = None
+    slack_client = None
+    if config.slack.enabled:
+        from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
+
+        from taskboy import slack
+
+        assert secrets is not None  # loaded above whenever slack is enabled
+        if not (secrets.slack_bot_token and secrets.slack_app_token):
+            raise ConfigError("slack.team_id is set but SLACK_BOT_TOKEN / SLACK_APP_TOKEN are not in the environment")
+        app, notifier = await slack.build(store, config, secrets.slack_bot_token)
+        slack_client = app.client
+        handler = AsyncSocketModeHandler(app, secrets.slack_app_token)
+        logger.info("slack intake enabled (team=%s)", config.slack.team_id)
+    else:
+        notifier = StdoutNotifier()
+        logger.info("slack intake disabled (services/slack.yaml enabled: false or team_id not set) — use `taskboy inject`")
+
+    broker = None
+    reviewer_broker = None
+    if config.runner == "claude":
+        from taskboy.broker import CredentialBroker
+
+        if not config.service_enabled("github"):
+            logger.info("github disabled in config — sessions run without git push auth or PR tools")
+        elif secrets is not None and secrets.github_enabled:
+            broker = CredentialBroker(secrets.github_app_id, secrets.github_installation_id, secrets.github_app_private_key, settings.BROKER_SOCKET, settings.GIT_CRED_HELPER)
+            await broker.start()
+            try:
+                await broker.verify((config.raw.get("github") or {}).get("approved_repos") or [])
+                logger.info("credential broker started, github app credentials verified (socket=%s)", settings.BROKER_SOCKET)
+            except Exception as e:
+                logger.warning("github app verification FAILED — git/PR operations will fail until fixed: %s", e)
+        else:
+            logger.info("github credentials not configured — sessions run without git push auth")
+        if config.reviewer.enabled:
+            if not config.service_enabled("github"):
+                logger.warning("reviewer is enabled but the github service is disabled — reviewer GitHub review tasks are disabled")
+            elif secrets is not None and secrets.reviewer_github_enabled:
+                candidate = CredentialBroker(secrets.reviewer_github_app_id, secrets.reviewer_github_installation_id, secrets.reviewer_github_app_private_key, settings.REVIEWER_BROKER_SOCKET, settings.GIT_CRED_HELPER)
+                try:
+                    await candidate.start()
+                    await candidate.verify((config.raw.get("github") or {}).get("approved_repos") or [])
+                except Exception as e:
+                    logger.warning("reviewer github app verification FAILED — reviewer GitHub review tasks are disabled: %s", e)
+                    await candidate.stop()
+                else:
+                    reviewer_broker = candidate
+                    logger.info("reviewer credential broker started, github app credentials verified (socket=%s)", settings.REVIEWER_BROKER_SOCKET)
+            else:
+                logger.warning("reviewer is enabled but the reviewer's GitHub identity is not configured — reviewer GitHub review tasks are disabled")
+        classify = Classifier(store, config).classify
+        run = ClaudeRunner(store, config, settings.WORKSPACES_ROOT, settings.MEMORY_ROOT, progress=notifier.progress, broker=broker, secrets=secrets, slack_client=slack_client, debug=getattr(notifier, "debug", None), reviewer_broker=reviewer_broker).run
+        assert secrets is not None
+        logger.info(
+            "session integrations: github=%s jira=%s confluence=%s sentry=%s aws=%s slack=%s",
+            broker is not None,
+            config.service_enabled("jira") and secrets.jira_enabled,
+            config.service_enabled("confluence") and secrets.jira_enabled,
+            config.service_enabled("sentry") and bool(secrets.sentry_token),
+            config.service_enabled("aws"),
+            slack_client is not None,
+        )
+    else:
+        classify = stub_classify
+        run = EchoRunner().run
+    orchestrator = Orchestrator(store, config, classify=classify, run=run, notifier=notifier, memory_root=settings.MEMORY_ROOT)
+    dashboard_store = None
+    dashboard_server = None
+    dashboard_task = None
+    if config.dashboard.enabled:
+        import uvicorn
+
+        from taskboy.dashboard import create_app
+
+        dashboard_store = Store(settings.DB_PATH)  # own connection; wal keeps it safe alongside the orchestrator's
+        dashboard_app = create_app(dashboard_store, config, notifier, secrets, orchestrator=orchestrator, ui_dist=settings.UI_DIST)
+
+        class EmbeddedServer(uvicorn.Server):
+            def install_signal_handlers(self) -> None:
+                pass  # the orchestrator owns process signals
+
+        dashboard_server = EmbeddedServer(uvicorn.Config(dashboard_app, host=config.dashboard.bind, port=config.dashboard.port, lifespan="off", log_level="warning"))
+
+        async def serve_dashboard() -> None:
+            try:
+                await dashboard_server.serve()
+            except asyncio.CancelledError:
+                raise
+            except BaseException as e:
+                dashboard_store.add_error("dashboard", type(e).__name__, str(e), traceback=traceback.format_exc())
+                logger.exception("dashboard stopped after an error")
+
+        dashboard_task = asyncio.create_task(serve_dashboard())
+        logger.info("mission control dashboard listening on %s:%s", config.dashboard.bind, config.dashboard.port)
+    review_poller = None
+    if should_start_review_poller(config, broker):
+        from taskboy.review_requests import ReviewRequestPoller
+
+        review_poller = asyncio.ensure_future(ReviewRequestPoller(store, config, broker, notifier, reviewer_broker=reviewer_broker).run())
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, lambda: asyncio.ensure_future(orchestrator.shutdown()))
+
+    audit_bucket = str((config.raw.get("audit") or {}).get("bucket") or "")
+
+    async def housekeeping_loop() -> None:
+        from taskboy import audit
+        from taskboy.issue_runs import fail_stalled_implementation_run, sync_in_review
+        from taskboy.orchestrator import expire_stale_blocked_tasks
+
+        async def _step(name: str, fn) -> None:
+            # runs fn (sync or async) in isolation so one failing step can't also skip sync_in_review for an hour (#87)
+            try:
+                result = fn()
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception as e:
+                store.add_error(name, type(e).__name__, str(e), traceback=traceback.format_exc())
+                debug = getattr(notifier, "debug", None)
+                if debug is not None:
+                    try:
+                        await debug.system_error(name, str(e))
+                    except Exception:
+                        # a notifier outage must never take housekeeping_loop down with it (nothing awaits `housekeeper`)
+                        logger.exception("debug notifier failed while reporting housekeeping step %s", name)
+                logger.exception("housekeeping step %s failed", name)
+
+        async def _notify_stalled() -> None:
+            stalled_task_id = fail_stalled_implementation_run(store)
+            if stalled_task_id is not None:
+                message = f"failed stalled implementation coordinator {stalled_task_id}"
+                logger.warning(message)
+                debug = getattr(notifier, "debug", None)
+                if debug is not None:
+                    await debug.system_error("housekeeping", message)
+
+        while True:
+            await _step("workspace_sweep", lambda: workspace.sweep_once(store, settings.WORKSPACES_ROOT, settings.MEMORY_ROOT, config.raw.get("retention") or {}))
+            await _step("expire_stale_blocked_tasks", lambda: expire_stale_blocked_tasks(store, notifier, config.raw.get("retention") or {}))
+            if audit_bucket:
+                await _step("audit_ship", lambda: audit.ship_once(store, audit_bucket))
+                await _step("audit_ship_admin", lambda: audit.ship_admin_once(store, audit_bucket))
+            if broker is not None:
+                await _step("repocache_refresh", lambda: repocache.refresh_all(store, broker, settings.REPOS_ROOT, (config.raw.get("github") or {}).get("approved_repos") or []))
+                await _step("sync_in_review", lambda: sync_in_review(store, broker))
+            await _step("fail_stalled_implementation_run", _notify_stalled)
+            await asyncio.sleep(3600)
+
+    await orchestrator.reconcile()
+    housekeeper = asyncio.ensure_future(housekeeping_loop())
+    scheduler_task = None
+    if config.runner == "claude":
+        from taskboy.scheduler import scheduler_loop, seed_default_schedules
+
+        seed_default_schedules(store, self_repo=str((config.raw.get("github") or {}).get("self_repo") or ""), github_enabled=config.service_enabled("github"))
+        scheduler_task = asyncio.ensure_future(scheduler_loop(store, config, notifier))
+    slack_task = None
+    if handler is not None:
+        slack_task = asyncio.ensure_future(serve_slack(handler, store, notifier))
+    logger.info("taskboy started (environment=%s, db=%s, audit_shipping=%s)", settings.ENVIRONMENT, settings.DB_PATH, bool(audit_bucket))
+    await orchestrator.dispatcher_loop()
+    housekeeper.cancel()
+    if scheduler_task is not None:
+        scheduler_task.cancel()
+    if review_poller is not None:
+        review_poller.cancel()
+    if slack_task is not None:
+        slack_task.cancel()
+    if handler is not None:
+        await handler.close_async()
+    if broker is not None:
+        await broker.stop()
+    if reviewer_broker is not None:
+        await reviewer_broker.stop()
+    if dashboard_server is not None:
+        dashboard_server.should_exit = True
+    if dashboard_task is not None:
+        try:
+            await asyncio.wait_for(dashboard_task, timeout=10)
+        except TimeoutError:
+            dashboard_task.cancel()
+    if dashboard_store is not None:
+        dashboard_store.close()
+    logger.info("taskboy stopped")
+    store.close()
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
+    try:
+        asyncio.run(amain())
+    except ConfigError as e:
+        print(f"invalid config: {e}", file=sys.stderr)
+        sys.exit(64)  # matches systemd RestartPreventExitStatus=64: don't crash-loop on bad config
+
+
+if __name__ == "__main__":
+    main()

taskboy/memory.py

@@ -0,0 +1,59 @@
+"""per-task markdown summaries (MEM-007) and thread-scoped recall for follow-ups (MEM-009/010).
+
+the structured record is the store itself; these files are the human-readable layer.
+scoping is structural: a follow-up only ever loads its immediate parent's summary — never
+cross-thread or cross-repo context.
+"""
+
+from pathlib import Path
+
+from taskboy.models import Task
+from taskboy.redact import redactor
+from taskboy.store import Store
+
+RESULT_MAX_CHARS = 4000
+RESULT_TRUNCATION_MARKER = "\n…(result truncated at 4000 chars)"
+
+
+def write_summary(memory_root: str, task: Task, artifacts: list[dict]) -> Path:
+    """written on every terminal transition; the compact durable record of what happened (MEM-006)."""
+    lines = [
+        f"# task {task.task_id}",
+        "",
+        f"- requested by: {task.slack_user_id} in {task.slack_channel_id} (thread {task.slack_thread_ts})",
+        f"- state: {task.state}",
+        f"- model: {task.model_alias or 'n/a'} ({task.routing_rationale or 'unrouted'})",
+        f"- created: {task.created_at}  finished: {task.finished_at or 'n/a'}",
+        f"- cost: ${task.cost_usd:.4f} over {task.num_turns} turns",
+        "",
+    ]
+    if artifacts:
+        lines.append("## artifacts")
+        for a in artifacts:
+            lines.append(f"- {a['kind']}: {a['external_id']}" + (f" ({a['url']})" if a.get("url") else ""))
+        lines.append("")
+    if task.result_summary:
+        result = task.result_summary
+        if len(result) > RESULT_MAX_CHARS:
+            result = result[: RESULT_MAX_CHARS - len(RESULT_TRUNCATION_MARKER)] + RESULT_TRUNCATION_MARKER
+        lines += ["## result", result, ""]
+    if task.error:
+        lines += ["## error", task.error, ""]
+    if task.blocked_reason:
+        lines += ["## blocked", task.blocked_reason, ""]
+    path = Path(memory_root) / "tasks" / f"{task.task_id}.md"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(redactor.redact("\n".join(lines)))
+    return path
+
+
+def read_summary(memory_root: str, task_id: str) -> str | None:
+    path = Path(memory_root) / "tasks" / f"{task_id}.md"
+    return path.read_text() if path.exists() else None
+
+
+def parent_context(store: Store, memory_root: str, task: Task) -> str | None:
+    """the immediate parent's summary only — it already compresses earlier lineage, bounding size (MEM-009/010)."""
+    if not task.parent_task_id:
+        return None
+    return read_summary(memory_root, task.parent_task_id)

taskboy/models.py

@@ -0,0 +1,103 @@
+"""task states, allowed transitions, and the dataclasses passed between modules."""
+
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+RECEIVED = "received"
+QUEUED = "queued"
+RUNNING = "running"
+BLOCKED = "blocked"
+COMPLETED = "completed"
+FAILED = "failed"
+CANCELLED = "cancelled"
+REFUSED = "refused"
+
+STATES = [RECEIVED, QUEUED, RUNNING, BLOCKED, COMPLETED, FAILED, CANCELLED, REFUSED]
+TERMINAL_STATES = [COMPLETED, FAILED, CANCELLED, REFUSED]
+
+# the sdk's reasoning-effort levels (issue #67); "auto" is a classifier-only value meaning "no opinion" and is
+# never persisted or passed to the sdk — see taskboy.classifier and taskboy.runner.session_option_kwargs
+EFFORT_LEVELS = ("low", "medium", "high", "xhigh", "max")
+
+# every transition in the system; store.transition rejects anything else (ORC-007)
+ALLOWED_TRANSITIONS: dict[str, list[str]] = {
+    # REFUSED only happens at classification time, so it's only reachable from RECEIVED (issue #16)
+    RECEIVED: [QUEUED, BLOCKED, FAILED, CANCELLED, REFUSED],
+    QUEUED: [RUNNING, FAILED, CANCELLED],
+    RUNNING: [COMPLETED, FAILED, BLOCKED, QUEUED, CANCELLED],
+    BLOCKED: [QUEUED, FAILED, CANCELLED],
+}
+
+
+def utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def new_task_id() -> str:
+    # date prefix keeps ids sortable and slack-readable
+    return "t" + datetime.now(timezone.utc).strftime("%Y%m%d") + "-" + uuid.uuid4().hex[:8]
+
+
+@dataclass
+class Task:
+    task_id: str
+    idempotency_key: str
+    state: str
+    attempt: int
+    resume_session_id: str | None
+    not_before: str | None
+    slack_team_id: str
+    slack_channel_id: str
+    slack_thread_ts: str
+    slack_message_ts: str
+    slack_user_id: str
+    request_text: str
+    thread_context: str | None
+    persona: str | None
+    schedule_name: str | None
+    parent_task_id: str | None
+    classification_json: str | None
+    task_type: str | None
+    complexity: str | None
+    risk: str | None
+    model_alias: str | None
+    model_id: str | None
+    profile: str | None
+    routing_rationale: str | None
+    model_override: str | None
+    effort_override: str | None
+    effort: str | None  # resolved by routing: effort_override > classifier's pick > profile default (issue #67)
+    session_id: str | None
+    workspace_path: str | None
+    max_budget_usd: float | None
+    max_turns: int | None
+    max_runtime_minutes: int | None
+    cost_usd: float
+    num_turns: int
+    blocked_reason: str | None
+    error: str | None
+    result_summary: str | None
+    reply: str | None
+    debug_thread_ts: str | None
+    debug_permalink: str | None
+    created_at: str
+    started_at: str | None
+    finished_at: str | None
+    updated_at: str
+
+
+@dataclass
+class Outcome:
+    """what a runner reports back for a finished session."""
+
+    state: str  # completed | failed | blocked
+    result_summary: str = ""
+    reply: str = ""
+    error: str = ""
+    blocked_reason: str = ""
+    session_id: str | None = None
+    cost_usd: float = 0.0
+    num_turns: int = 0
+    retryable: bool = False
+    retry_not_before: str | None = None

taskboy/mrkdwn.py

@@ -0,0 +1,19 @@
+"""small markdown-to-Slack-mrkdwn conversion for lifecycle posts."""
+
+import re
+
+
+def to_mrkdwn(text: str) -> str:
+    """markdown -> slack mrkdwn. code fences pass through untouched.
+
+    Inline-code spans are intentionally not shielded from bold and link conversion.
+    """
+    parts = re.split(r"(```.*?```)", text, flags=re.S)
+    for index in range(0, len(parts), 2):
+        part = parts[index]
+        part = re.sub(r"^#{1,6}\s+(.+)$", r"*\1*", part, flags=re.MULTILINE)
+        part = re.sub(r"\*\*(.+?)\*\*", r"*\1*", part)
+        part = re.sub(r"^(\s*)-\s+", r"\1• ", part, flags=re.MULTILINE)
+        part = re.sub(r"\[([^\]]+)\]\((https?://[^)\s]+)\)", r"<\2|\1>", part)
+        parts[index] = part
+    return "".join(parts)

taskboy/notify.py

@@ -0,0 +1,41 @@
+"""notifier interface (duck-typed) + stdout implementation, used before slack lands and by `inject --no-slack`.
+
+any notifier must provide: ack, started, completed, failed, blocked, issue_blocked, recovered, refused, refuse_intake, answer.
+"""
+
+from taskboy.models import Task
+
+
+class StdoutNotifier:
+    async def ack(self, task: Task) -> None:
+        print(f"[{task.task_id}] accepted")
+
+    async def started(self, task: Task) -> None:
+        print(f"[{task.task_id}] running")
+
+    async def completed(self, task: Task) -> None:
+        print(f"[{task.task_id}] completed: {task.result_summary}")
+
+    async def failed(self, task: Task, error: str) -> None:
+        print(f"[{task.task_id}] failed: {error}")
+
+    async def blocked(self, task: Task) -> None:
+        print(f"[{task.task_id}] blocked: {task.blocked_reason}")
+
+    async def issue_blocked(self, task: Task, issue: dict) -> None:
+        print(f"[{task.task_id}] blocked: {task.blocked_reason} (reopened issue #{issue['id']})")
+
+    async def recovered(self, task: Task) -> None:
+        print(f"[{task.task_id}] requeued after restart")
+
+    async def refused(self, task: Task, reason: str) -> None:
+        print(f"[{task.task_id}] refused: {reason}")
+
+    async def refuse_intake(self, channel_id: str, thread_ts: str, reason: str) -> None:
+        print(f"[intake {channel_id}/{thread_ts}] refused: {reason}")
+
+    async def answer(self, channel_id: str, thread_ts: str, text: str) -> None:
+        print(f"[answer {channel_id}/{thread_ts}] {text}")
+
+    async def progress(self, task: Task, message: str) -> None:
+        print(f"[{task.task_id}] progress: {message}")