Discord Cli

# Discord user token (from browser DevTools → Network → Authorization header)
DISCORD_TOKEN=your_token_here

# Optional: Anthropic API key for AI analysis
# ANTHROPIC_API_KEY=sk-ant-...

name: Bug Report
description: Report a bug or unexpected behavior
labels: ["bug"]
body:
  - type: input
    id: version
    attributes:
      label: Version
      description: "Run `discord --version` or `pip show kabi-discord-cli | grep Version`"
      placeholder: "e.g. 1.0.0"
    validations:
      required: true
  - type: dropdown
    id: os
    attributes:
      label: Operating System
      options:
        - macOS
        - Linux
        - Windows
        - Other
    validations:
      required: true
  - type: textarea
    id: description
    attributes:
      label: What happened?
      description: Describe the bug clearly.
    validations:
      required: true
  - type: textarea
    id: expected
    attributes:
      label: Expected behavior
      description: What did you expect to happen?
    validations:
      required: true
  - type: textarea
    id: reproduce
    attributes:
      label: Steps to reproduce
      description: "Commands or steps to reproduce the issue. Use `discord -v <command>` for debug output."
      render: bash
  - type: textarea
    id: logs
    attributes:
      label: Error output / logs
      description: Paste any error messages or verbose output here.
      render: text

name: Feature Request
description: Suggest a new feature or improvement
labels: ["enhancement"]
body:
  - type: input
    id: version
    attributes:
      label: Current version
      description: "Run `discord --version` or `pip show kabi-discord-cli | grep Version`"
      placeholder: "e.g. 1.0.0"
    validations:
      required: false
  - type: textarea
    id: description
    attributes:
      label: Describe the feature
      description: What would you like to see added or changed?
    validations:
      required: true
  - type: textarea
    id: use_case
    attributes:
      label: Use case
      description: Why do you need this feature? How would you use it?

name: CI

on:
  push:
    branches: [main]
  pull_request:
  workflow_call:

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ["3.10", "3.12", "3.14"]

    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - uses: astral-sh/setup-uv@v6

      - name: Install dependencies
        run: uv sync --extra dev

      - name: Lint
        run: uv run ruff check .

      - name: Test
        run: uv run python -m pytest -q

      - name: Build
        run: uv build

      - name: Twine check
        run: uv run twine check dist/*

name: Publish to PyPI

on:
  push:
    tags:
      - "v*"
  workflow_dispatch:

jobs:
  verify:
    uses: ./.github/workflows/ci.yml

  publish:
    needs: verify
    runs-on: ubuntu-latest
    environment: pypi
    permissions:
      id-token: write

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - name: Setup uv
        uses: astral-sh/setup-uv@v6

      - name: Build package
        run: uv build

      - name: Publish to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1

__pycache__/
__pycache__/
*.egg-info/
.venv/
.env
data/
*.db
*.db-*
.pytest_cache/
dist/

Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.

You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

[project]
name = "kabi-discord-cli"
version = "0.2.8"
description = "Discord CLI for local-first sync, search, export, and agent-friendly retrieval"
readme = "README.md"
license = "Apache-2.0"
requires-python = ">=3.10"
authors = [{ name = "jackwener" }]
keywords = ["discord", "cli", "sqlite", "agent", "discord-cli"]
classifiers = [
    "Development Status :: 3 - Alpha",
    "Environment :: Console",
    "Intended Audience :: Developers",
    "License :: OSI Approved :: Apache Software License",
    "Programming Language :: Python :: 3",
    "Programming Language :: Python :: 3.10",
    "Programming Language :: Python :: 3.11",
    "Programming Language :: Python :: 3.12",
    "Programming Language :: Python :: 3.13",
    "Programming Language :: Python :: 3.14",
    "Topic :: Communications :: Chat",
    "Topic :: Utilities",
]
urls = { Homepage = "https://github.com/jackwener/discord-cli", Repository = "https://github.com/jackwener/discord-cli", Issues = "https://github.com/jackwener/discord-cli/issues" }
dependencies = [
    "httpx>=0.27",
    "click>=8.0",
    "rich>=13.0",
    "python-dotenv>=1.0",
    "PyYAML>=6.0",
]

[project.optional-dependencies]
dev = ["build>=1.2", "pytest>=8.0", "pytest-asyncio>=0.24", "ruff>=0.11", "twine>=6.0"]


[project.scripts]
discord = "discord_cli.cli.main:cli"

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.hatch.build.targets.wheel]
packages = ["src/discord_cli"]

[tool.hatch.build.targets.sdist]
include = [
    "src/discord_cli",
    "tests",
    "README.md",
    "README_CN.md",
    "SKILL.md",
    ".env.example",
    "LICENSE",
    "CHANGELOG.md",
    "CONTRIBUTING.md",
]

[tool.ruff]
target-version = "py310"
line-length = 100

"""discord-cli — Discord CLI for fetching chat history."""

try:
    from importlib.metadata import version

    __version__ = version("kabi-discord-cli")
except Exception:
    __version__ = "0.0.0"

"""Discord token extraction from local browser and Discord client data."""

from __future__ import annotations

import os
import re
import sys
from pathlib import Path


# Discord token regex patterns
# Tokens can be:
#   - Regular user token: base64(user_id).timestamp.hmac
#   - MFA token: mfa.base64_encoded_string
_TOKEN_PATTERNS = [
    re.compile(r'[\w-]{24,}\.[\w-]{6}\.[\w-]{27,}'),
    re.compile(r'mfa\.[\w-]{84}'),
]


def _get_search_paths() -> list[tuple[str, Path]]:
    """Return list of (source_name, leveldb_path) to search for tokens."""
    home = Path.home()

    if sys.platform == "darwin":
        paths = [
            ("Discord App", home / "Library/Application Support/discord/Local Storage/leveldb"),
            ("Discord PTB", home / "Library/Application Support/discordptb/Local Storage/leveldb"),
            ("Discord Canary", home / "Library/Application Support/discordcanary/Local Storage/leveldb"),
            ("Chrome", home / "Library/Application Support/Google/Chrome/Default/Local Storage/leveldb"),
            ("Brave", home / "Library/Application Support/BraveSoftware/Brave-Browser/Default/Local Storage/leveldb"),
            ("Edge", home / "Library/Application Support/Microsoft Edge/Default/Local Storage/leveldb"),
            ("Firefox", home / "Library/Application Support/Firefox/Profiles"),
        ]
    elif os.name == "nt":
        appdata = Path(os.environ.get("APPDATA", ""))
        local_appdata = Path(os.environ.get("LOCALAPPDATA", ""))
        paths = [
            ("Discord App", appdata / "discord/Local Storage/leveldb"),
            ("Discord PTB", appdata / "discordptb/Local Storage/leveldb"),
            ("Discord Canary", appdata / "discordcanary/Local Storage/leveldb"),
            ("Chrome", local_appdata / "Google/Chrome/User Data/Default/Local Storage/leveldb"),
            ("Brave", local_appdata / "BraveSoftware/Brave-Browser/User Data/Default/Local Storage/leveldb"),
            ("Edge", local_appdata / "Microsoft/Edge/User Data/Default/Local Storage/leveldb"),
        ]
    else:  # Linux
        config = Path(os.environ.get("XDG_CONFIG_HOME", home / ".config"))
        paths = [
            ("Discord App", config / "discord/Local Storage/leveldb"),
            ("Discord PTB", config / "discordptb/Local Storage/leveldb"),
            ("Discord Canary", config / "discordcanary/Local Storage/leveldb"),
            ("Chrome", config / "google-chrome/Default/Local Storage/leveldb"),
            ("Brave", config / "BraveSoftware/Brave-Browser/Default/Local Storage/leveldb"),
        ]

    return [(name, p) for name, p in paths if p.exists()]


def _extract_tokens_from_file(filepath: Path) -> list[str]:
    """Extract Discord tokens from a single file by regex scanning."""
    tokens: list[str] = []
    try:
        data = filepath.read_bytes().decode("utf-8", errors="ignore")
        for pattern in _TOKEN_PATTERNS:
            tokens.extend(pattern.findall(data))
    except (OSError, PermissionError):
        pass
    return tokens


def find_tokens() -> list[dict]:
    """Scan known browser/Discord client paths for tokens.

    Returns list of {source, token} dicts, deduplicated by token.
    """
    search_paths = _get_search_paths()
    found: dict[str, str] = {}  # token -> source

    for source_name, db_path in search_paths:
        if not db_path.is_dir():
            continue

        # Scan .ldb and .log files
        for ext in ("*.ldb", "*.log"):
            for filepath in db_path.glob(ext):
                for token in _extract_tokens_from_file(filepath):
                    if token not in found:
                        found[token] = source_name

    return [{"source": source, "token": token} for token, source in found.items()]


def save_token_to_env(token: str, env_path: Path | None = None) -> Path:
    """Save token to .env file."""
    if env_path is None:
        env_path = Path.cwd() / ".env"

    lines = []
    token_found = False

    if env_path.exists():
        for line in env_path.read_text().splitlines():
            if line.startswith("DISCORD_TOKEN="):
                lines.append(f"DISCORD_TOKEN={token}")
                token_found = True
            else:
                lines.append(line)

    if not token_found:
        lines.append(f"DISCORD_TOKEN={token}")

    env_path.write_text("\n".join(lines) + "\n")
    return env_path

"""Helpers for resolving stored channel names safely."""

import click

from ..db import ChannelResolutionError, MessageDB
from ._output import emit_error


def resolve_channel_id_or_raise(db: MessageDB, channel: str) -> str:
    """Resolve a stored channel ID or raise a CLI-friendly error."""
    try:
        return db.resolve_channel(channel)["channel_id"]
    except ChannelResolutionError as exc:
        if emit_error("channel_resolution_error", str(exc)):
            raise SystemExit(1) from None
        raise click.ClickException(str(exc)) from exc

"""Shared structured output helpers for discord-cli."""

from __future__ import annotations

import json
import os
import sys
from typing import Any, Callable

import click
import yaml

_OUTPUT_ENV = "OUTPUT"
_SCHEMA_VERSION = "1"


def default_structured_format(*, as_json: bool, as_yaml: bool) -> str | None:
    """Resolve explicit flags first, then env override, then TTY default."""
    if as_json and as_yaml:
        raise click.UsageError("Use only one of --json or --yaml.")
    if as_yaml:
        return "yaml"
    if as_json:
        return "json"

    output_mode = os.getenv(_OUTPUT_ENV, "auto").strip().lower()
    if output_mode == "yaml":
        return "yaml"
    if output_mode == "json":
        return "json"
    if output_mode == "rich":
        return None

    if not sys.stdout.isatty():
        return "yaml"
    return None


def structured_output_options(command: Callable) -> Callable:
    """Add --json/--yaml options to a Click command."""
    command = click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML")(command)
    command = click.option("--json", "as_json", is_flag=True, help="Output as JSON")(command)
    return command


def dump_structured(data: Any, *, fmt: str) -> str:
    """Serialize data to JSON or YAML text."""
    if fmt == "json":
        return json.dumps(data, ensure_ascii=False, indent=2, default=str)
    if fmt == "yaml":
        return yaml.safe_dump(
            data,
            allow_unicode=True,
            sort_keys=False,
            default_flow_style=False,
        )
    raise ValueError(f"Unsupported structured format: {fmt}")


def emit_structured(data: Any, *, as_json: bool, as_yaml: bool) -> bool:
    """Emit structured output and return True when a structured format was used."""
    fmt = default_structured_format(as_json=as_json, as_yaml=as_yaml)
    if not fmt:
        return False
    click.echo(dump_structured(_normalize_success_payload(data), fmt=fmt))
    return True


def success_payload(data: Any) -> dict[str, Any]:
    """Wrap structured success data in the shared agent schema."""
    return {
        "ok": True,
        "schema_version": _SCHEMA_VERSION,
        "data": data,
    }


def error_payload(code: str, message: str, *, details: Any | None = None) -> dict[str, Any]:
    """Wrap structured error data in the shared agent schema."""
    error = {
        "code": code,
        "message": message,
    }
    if details is not None:
        error["details"] = details
    return {
        "ok": False,
        "schema_version": _SCHEMA_VERSION,
        "error": error,
    }


def _normalize_success_payload(data: Any) -> Any:
    """Wrap plain structured data in the shared agent success schema."""
    if isinstance(data, dict) and data.get("schema_version") == _SCHEMA_VERSION and "ok" in data:
        return data
    return success_payload(data)


def emit_error(
    code: str,
    message: str,
    *,
    as_json: bool | None = None,
    as_yaml: bool | None = None,
    details: Any | None = None,
) -> bool:
    """Emit a structured error when the active output mode is machine-readable."""
    if as_json is None or as_yaml is None:
        ctx = click.get_current_context(silent=True)
        params = ctx.params if ctx is not None else {}
        as_json = bool(params.get("as_json", False)) if as_json is None else as_json
        as_yaml = bool(params.get("as_yaml", False)) if as_yaml is None else as_yaml

    fmt = default_structured_format(as_json=bool(as_json), as_yaml=bool(as_yaml))
    if fmt is None:
        return False
    click.echo(dump_structured(error_payload(code, message, details=details), fmt=fmt))
    return True

"""Data commands — export, purge."""

import json
import os
import sys

import click
from rich.console import Console
import yaml

from ._channels import resolve_channel_id_or_raise
from ._output import default_structured_format, error_payload
from ..db import MessageDB

console = Console(stderr=True)


@click.group("data", invoke_without_command=True)
def data_group():
    """Data management commands (registered at top-level)."""
    pass


@data_group.command("export")
@click.argument("channel")
@click.option("-f", "--format", "fmt", type=click.Choice(["text", "json", "yaml"]), default="text")
@click.option("-o", "--output", "output_file", help="Output file path")
@click.option("--hours", type=int, help="Only export last N hours")
def export(channel: str, fmt: str, output_file: str | None, hours: int | None):
    """Export messages from CHANNEL to text or JSON."""
    with MessageDB() as db:
        channel_id = resolve_channel_id_or_raise(db, channel)
        msgs = db.get_recent(channel_id=channel_id, hours=hours, limit=100000)

    if not msgs:
        structured_fmt = fmt if fmt in {"json", "yaml"} else default_structured_format(as_json=False, as_yaml=False)
        if structured_fmt in {"json", "yaml"} and output_file is None:
            click.echo(
                (
                    json.dumps(error_payload("no_messages", f"No messages found for '{channel}'."), ensure_ascii=False, indent=2, default=str)
                    if structured_fmt == "json"
                    else yaml.safe_dump(error_payload("no_messages", f"No messages found for '{channel}'."), allow_unicode=True, sort_keys=False, default_flow_style=False)
                )
            )
            raise SystemExit(1) from None
        console.print(f"[yellow]No messages found for '{channel}'.[/yellow]")
        return

    auto_yaml = fmt == "text" and output_file is None and os.getenv("OUTPUT", "auto").strip().lower() != "rich" and not sys.stdout.isatty()
    if fmt == "json":
        content = json.dumps(msgs, ensure_ascii=False, indent=2, default=str)
    elif fmt == "yaml" or auto_yaml:
        content = yaml.safe_dump(msgs, allow_unicode=True, sort_keys=False, default_flow_style=False)
    else:
        lines = []
        for msg in msgs:
            ts = (msg.get("timestamp") or "")[:19]
            sender = msg.get("sender_name") or "Unknown"
            text = msg.get("content") or ""
            lines.append(f"[{ts}] {sender}: {text}")
        content = "\n".join(lines)

    if output_file:
        with open(output_file, "w", encoding="utf-8") as f:
            f.write(content)
        console.print(f"[green]✓[/green] Exported {len(msgs)} messages to {output_file}")
    else:
        console.print(content)


@data_group.command("purge")
@click.argument("channel")
@click.option("-y", "--yes", is_flag=True, help="Skip confirmation")
def purge(channel: str, yes: bool):
    """Delete all stored messages for CHANNEL."""
    with MessageDB() as db:
        channel_id = resolve_channel_id_or_raise(db, channel)
        if not yes:
            count = db.count(channel_id)
            if not click.confirm(f"Delete {count} messages from channel {channel_id}?"):
                return

        deleted = db.delete_channel(channel_id)

    console.print(f"[green]✓[/green] Deleted {deleted} messages")

"""Discord subcommands — guilds, channels, history, sync, sync-all, search, members."""

import asyncio
from contextlib import suppress

import click
from rich.console import Console
from rich.progress import Progress, SpinnerColumn, TextColumn
from rich.table import Table

from ..client import (
    fetch_messages,
    get_client,
    get_guild_info,
    list_channels,
    list_guilds,
    list_members,
    resolve_guild_id,
    search_guild_messages,
)
from ..db import MessageDB
from ._output import emit_error, emit_structured, structured_output_options

console = Console(stderr=True)


@click.group("dc")
def discord_group():
    """Discord operations — list servers, fetch history, sync."""
    pass


async def _fetch_channel_context(client, channel_id: str) -> dict[str, str | None]:
    """Resolve channel and guild names for a channel."""
    channel_name = None
    guild_name = None
    guild_id = None

    with suppress(Exception):
        response = await client.get(f"/channels/{channel_id}")
        if response.status_code == 200:
            data = response.json()
            channel_name = data.get("name")
            guild_id = data.get("guild_id")
            if guild_id:
                guild = await get_guild_info(client, guild_id)
                if guild:
                    guild_name = guild.get("name")

    return {
        "channel_name": channel_name,
        "guild_name": guild_name,
        "guild_id": guild_id,
    }


def _annotate_messages(messages: list[dict], context: dict[str, str | None]) -> list[dict]:
    """Attach channel and guild metadata to fetched messages."""
    for msg in messages:
        msg["guild_id"] = context.get("guild_id")
        msg["guild_name"] = context.get("guild_name")
        msg["channel_name"] = context.get("channel_name")
    return messages


def _format_message(msg: dict, *, include_channel: bool = False) -> str:
    """Format a single message for console output."""
    ts = str(msg.get("timestamp", ""))[:19]
    sender = msg.get("sender_name") or "Unknown"
    content = (msg.get("content") or "").replace("\n", " ")[:300]
    channel_name = msg.get("channel_name") or ""
    prefix = f"[cyan]#{channel_name}[/cyan] | " if include_channel and channel_name else ""
    return f"[dim]{ts}[/dim] {prefix}[bold]{sender}[/bold]: {content}"


async def _tail_fetch_once(
    client,
    db: MessageDB,
    channel_id: str,
    *,
    after: str | None,
    fetch_limit: int,
    context: dict[str, str | None],
    store: bool,
) -> tuple[list[dict], str | None, int]:
    """Fetch a single incremental batch for tail mode."""
    messages = await fetch_messages(client, channel_id, limit=fetch_limit, after=after)
    if not messages:
        return [], after, 0

    _annotate_messages(messages, context)
    inserted = db.insert_batch(messages) if store else 0
    return messages, messages[-1]["msg_id"], inserted


@discord_group.command("guilds")
@structured_output_options
def dc_guilds(as_json: bool, as_yaml: bool):
    """List joined Discord servers."""

    async def _run():
        async with get_client() as client:
            return await list_guilds(client)

    guilds = asyncio.run(_run())

    if emit_structured(guilds, as_json=as_json, as_yaml=as_yaml):
        return

    table = Table(title="Discord Servers")
    table.add_column("ID", style="dim")
    table.add_column("Name", style="bold")
    table.add_column("Owner", justify="center")

    for g in guilds:
        table.add_row(g["id"], g["name"], "✓" if g["owner"] else "")

    console.print(table)
    console.print(f"\nTotal: {len(guilds)} servers")


@discord_group.command("channels")
@click.argument("guild")
@structured_output_options
def dc_channels(guild: str, as_json: bool, as_yaml: bool):
    """List text channels in a GUILD (server ID or name)."""

    async def _run():
        async with get_client() as client:
            guild_id = await resolve_guild_id(client, guild)
            if not guild_id:
                if emit_error("guild_not_found", f"Guild '{guild}' not found.", as_json=as_json, as_yaml=as_yaml):
                    raise SystemExit(1) from None
                console.print(f"[red]Guild '{guild}' not found.[/red]")
                return []
            return await list_channels(client, guild_id)

    channels = asyncio.run(_run())
    if not channels:
        return

    if emit_structured(channels, as_json=as_json, as_yaml=as_yaml):
        return

    table = Table(title="Text Channels")
    table.add_column("ID", style="dim")
    table.add_column("Name", style="bold")
    table.add_column("Topic", max_width=50)

    for ch in channels:
        table.add_row(ch["id"], f"#{ch['name']}", (ch.get("topic") or "")[:50])

    console.print(table)
    console.print(f"\nTotal: {len(channels)} text channels")


@discord_group.command("history")
@click.argument("channel")
@click.option("-n", "--limit", default=1000, help="Max messages to fetch")
@click.option("--guild-name", help="Guild name to store with messages")
@click.option("--channel-name", help="Channel name to store with messages")
@structured_output_options
def dc_history(channel: str, limit: int, guild_name: str | None, channel_name: str | None, as_json: bool, as_yaml: bool):
    """Fetch historical messages from CHANNEL (channel ID)."""

    async def _run():
        with MessageDB() as db:
            async with get_client() as client:
                context = await _fetch_channel_context(client, channel)
                if channel_name:
                    context["channel_name"] = channel_name
                elif context.get("channel_name") is None:
                    context["channel_name"] = channel

                if guild_name:
                    context["guild_name"] = guild_name

                with Progress(
                    SpinnerColumn(),
                    TextColumn("[progress.description]{task.description}"),
                    console=console,
                ) as progress:
                    task = progress.add_task(
                        f"Fetching messages from {context.get('channel_name') or channel}...",
                        total=None,
                    )
                    messages = await fetch_messages(client, channel, limit=limit)
                    progress.update(task, description=f"Fetched {len(messages)} messages")

                _annotate_messages(messages, context)

                inserted = db.insert_batch(messages)
                return len(messages), inserted

    total, inserted = asyncio.run(_run())
    payload = {"fetched": total, "stored": inserted}
    if emit_structured(payload, as_json=as_json, as_yaml=as_yaml):
        return
    console.print(f"\n[green]✓[/green] Fetched {total} messages, stored {inserted} new")


@discord_group.command("sync")
@click.argument("channel")
@click.option("-n", "--limit", default=5000, help="Max messages per sync")
@structured_output_options
def dc_sync(channel: str, limit: int, as_json: bool, as_yaml: bool):
    """Incremental sync — fetch only new messages from CHANNEL."""

    async def _run():
        with MessageDB() as db:
            last_id = db.get_last_msg_id(channel)
            if last_id:
                console.print(f"Syncing from msg_id > {last_id}...")

            async with get_client() as client:
                context = await _fetch_channel_context(client, channel)

                with Progress(
                    SpinnerColumn(),
                    TextColumn("[progress.description]{task.description}"),
                    console=console,
                ) as progress:
                    task_id = progress.add_task(
                        f"Syncing {context.get('channel_name') or channel}...",
                        total=None,
                    )
                    messages = await fetch_messages(client, channel, limit=limit, after=last_id)
                    progress.update(task_id, description=f"Fetched {len(messages)} new messages")

                _annotate_messages(messages, context)

                inserted = db.insert_batch(messages)
                return len(messages), inserted

    total, inserted = asyncio.run(_run())
    payload = {"fetched": total, "stored": inserted}
    if emit_structured(payload, as_json=as_json, as_yaml=as_yaml):
        return
    console.print(f"\n[green]✓[/green] Synced {total} messages, stored {inserted} new")


@discord_group.command("tail")
@click.argument("channel")
@click.option("-n", "--limit", default=20, help="Show last N messages before following")
@click.option("--interval", default=5.0, type=click.FloatRange(min=0.5), help="Polling interval in seconds")
@click.option("--poll-limit", default=100, type=click.IntRange(1, 100), help="Max new messages fetched per poll")
@click.option("--store/--no-store", default=True, help="Store tailed messages in local SQLite")
@click.option("--once", is_flag=True, help="Show initial snapshot and exit")
def dc_tail(channel: str, limit: int, interval: float, poll_limit: int, store: bool, once: bool):
    """Tail a channel and follow new messages."""

    async def _run():
        with MessageDB() as db:
            async with get_client() as client:
                context = await _fetch_channel_context(client, channel)
                channel_label = context.get("channel_name") or channel
                guild_label = context.get("guild_name")
                scope = f"{guild_label} > #{channel_label}" if guild_label else f"#{channel_label}"
                last_id = db.get_last_msg_id(channel)

                if limit > 0:
                    initial = await fetch_messages(client, channel, limit=limit)
                    _annotate_messages(initial, context)
                    if store and initial:
                        db.insert_batch(initial)
                    for msg in initial:
                        console.print(_format_message(msg))
                    if initial:
                        last_id = initial[-1]["msg_id"]
                elif last_id is None:
                    latest = await fetch_messages(client, channel, limit=1)
                    if latest:
                        _annotate_messages(latest, context)
                        if store:
                            db.insert_batch(latest)
                        last_id = latest[-1]["msg_id"]

                if once:
                    return

                console.print(
                    f"\n[green]Watching[/green] {scope} "
                    f"[dim](poll every {interval:g}s, Ctrl-C to stop)[/dim]"
                )

                while True:
                    messages, last_id, inserted = await _tail_fetch_once(
                        client,
                        db,
                        channel,
                        after=last_id,
                        fetch_limit=poll_limit,
                        context=context,
                        store=store,
                    )
                    for msg in messages:
                        console.print(_format_message(msg))
                    if messages and store:
                        console.print(f"[dim]+{inserted} stored[/dim]")
                    await asyncio.sleep(interval)

    try:
        asyncio.run(_run())
    except KeyboardInterrupt:
        console.print("\n[yellow]Stopped tailing.[/yellow]")


@discord_group.command("sync-all")
@click.option("-n", "--limit", default=5000, help="Max messages per channel")
def dc_sync_all(limit: int):
    """Sync ALL channels in the database."""

    async def _run():
        with MessageDB() as db:
            async with get_client() as client:
                guilds = await list_guilds(client)
                channels: list[dict[str, str | None]] = []
                for guild in guilds:
                    guild_channels = await list_channels(client, guild["id"])
                    for channel in guild_channels:
                        channels.append(
                            {
                                "guild_id": guild["id"],
                                "guild_name": guild["name"],
                                "channel_id": channel["id"],
                                "channel_name": channel["name"],
                            }
                        )

                if not channels:
                    if emit_error("no_channels", "No text channels found for this account."):
                        return {}
                    console.print("[yellow]No text channels found for this account.[/yellow]")
                    return {}

                console.print(
                    f"Discovered {len(channels)} channels across {len(guilds)} guilds. Syncing..."
                )

                results: dict[str, int] = {}
                for ch in channels:
                    ch_id = ch["channel_id"]
                    ch_name = ch.get("channel_name") or ch_id
                    last_id = db.get_last_msg_id(ch_id)
                    try:
                        messages = await fetch_messages(client, ch_id, limit=limit, after=last_id)
                        for msg in messages:
                            msg["guild_name"] = ch.get("guild_name")
                            msg["channel_name"] = ch.get("channel_name")
                        inserted = db.insert_batch(messages)
                        results[ch_name] = inserted
                        if inserted > 0:
                            console.print(f"  [green]✓[/green] {ch_name}: +{inserted}")
                        else:
                            console.print(f"  [dim]✓ {ch_name}: no new messages[/dim]")
                    except Exception as e:
                        console.print(f"  [red]✗ {ch_name}: {e}[/red]")
                        results[ch_name] = 0
                return results

    results = asyncio.run(_run())
    total_new = sum(results.values())
    console.print(f"\n[green]✓[/green] Synced {total_new} new messages across {len(results)} channels")


@discord_group.command("search")
@click.argument("guild")
@click.argument("keyword")
@click.option("-c", "--channel", help="Filter by channel ID")
@click.option("-n", "--limit", default=25, help="Max results")
@structured_output_options
def dc_search(guild: str, keyword: str, channel: str | None, limit: int, as_json: bool, as_yaml: bool):
    """Search messages in a GUILD by KEYWORD (Discord native search)."""

    async def _run():
        async with get_client() as client:
            guild_id = await resolve_guild_id(client, guild)
            if not guild_id:
                if emit_error("guild_not_found", f"Guild '{guild}' not found.", as_json=as_json, as_yaml=as_yaml):
                    raise SystemExit(1) from None
                console.print(f"[red]Guild '{guild}' not found.[/red]")
                return []
            return await search_guild_messages(client, guild_id, keyword, channel_id=channel, limit=limit)

    results = asyncio.run(_run())

    if not results:
        if emit_structured([], as_json=as_json, as_yaml=as_yaml):
            return
        console.print("[yellow]No messages found.[/yellow]")
        return

    if emit_structured(results, as_json=as_json, as_yaml=as_yaml):
        return

    for msg in results:
        ts = str(msg.get("timestamp", ""))[:19]
        sender = msg.get("sender_name") or "Unknown"
        content = (msg.get("content") or "")[:200]
        console.print(f"[dim]{ts}[/dim] [bold]{sender}[/bold]: {content}")

    console.print(f"\n[dim]Found {len(results)} messages[/dim]")


@discord_group.command("members")
@click.argument("guild")
@click.option("-n", "--max", "limit", default=50, help="Max members to list")
@structured_output_options
def dc_members(guild: str, limit: int, as_json: bool, as_yaml: bool):
    """List members of a GUILD (server)."""

    async def _run():
        async with get_client() as client:
            guild_id = await resolve_guild_id(client, guild)
            if not guild_id:
                if emit_error("guild_not_found", f"Guild '{guild}' not found.", as_json=as_json, as_yaml=as_yaml):
                    raise SystemExit(1) from None
                console.print(f"[red]Guild '{guild}' not found.[/red]")
                return []
            return await list_members(client, guild_id, limit=limit)

    members = asyncio.run(_run())

    if not members:
        if emit_structured([], as_json=as_json, as_yaml=as_yaml):
            return
        console.print("[yellow]No members found (may require Privileged Intents).[/yellow]")
        return

    if emit_structured(members, as_json=as_json, as_yaml=as_yaml):
        return

    table = Table(title=f"Members ({len(members)})")
    table.add_column("ID", style="dim")
    table.add_column("Username", style="bold")
    table.add_column("Display", style="cyan")
    table.add_column("Nick", style="green")
    table.add_column("Bot", justify="center")

    for m in members:
        display = m.get("global_name") or ""
        table.add_row(
            m["id"],
            f"@{m['username']}" if m.get("username") else "—",
            display,
            m.get("nick") or "",
            "🤖" if m.get("bot") else "",
        )

    console.print(table)


@discord_group.command("info")
@click.argument("guild")
@structured_output_options
def dc_info(guild: str, as_json: bool, as_yaml: bool):
    """Show detailed info about a GUILD (server)."""

    async def _run():
        async with get_client() as client:
            guild_id = await resolve_guild_id(client, guild)
            if not guild_id:
                if emit_error("guild_not_found", f"Could not find guild: {guild}", as_json=as_json, as_yaml=as_yaml):
                    raise SystemExit(1) from None
                return None
            return await get_guild_info(client, guild_id)

    info = asyncio.run(_run())
    if not info:
        console.print(f"[red]Could not find guild: {guild}[/red]")
        return

    if emit_structured(info, as_json=as_json, as_yaml=as_yaml):
        return

    table = Table(title="Guild Info", show_header=False)
    table.add_column("Field", style="bold")
    table.add_column("Value")

    for k, v in info.items():
        table.add_row(k, str(v) if v is not None else "—")

    console.print(table)

"""discord-cli — CLI entry point."""

import logging

import click
from rich.console import Console
from rich.table import Table

from .data import data_group
from .discord_cmds import discord_group
from ._output import emit_structured, error_payload, structured_output_options, success_payload
from .query import query_group

console = Console(stderr=True)


def _discord_user_payload(user: dict) -> dict[str, object]:
    """Normalize Discord user info for structured agent output."""
    return {
        "id": user.get("id", ""),
        "name": user.get("global_name") or user.get("username", ""),
        "username": user.get("username", ""),
        "global_name": user.get("global_name") or "",
        "email": user.get("email") or "",
        "phone": user.get("phone") or "",
        "mfa_enabled": bool(user.get("mfa_enabled", False)),
        "premium_type": user.get("premium_type", 0),
        "created_at": user.get("created_at", ""),
    }


@click.group()
@click.version_option(package_name="kabi-discord-cli")
@click.option("-v", "--verbose", is_flag=True, help="Enable debug logging.")
def cli(verbose: bool):
    """discord — CLI for fetching Discord chat history and searching messages."""
    level = logging.DEBUG if verbose else logging.WARNING
    logging.basicConfig(level=level, format="%(name)s: %(message)s")


@cli.command("auth")
@click.option("--save", is_flag=True, help="Save found token to .env automatically")
def auth(save: bool):
    """Extract Discord token from local browser/Discord client."""
    import httpx

    from ..auth import find_tokens, save_token_to_env

    console.print(
        "[yellow]Warning:[/yellow] discord-cli uses a Discord user token from your local "
        "session. This may violate Discord's terms or trigger account restrictions. "
        "Use it only on accounts you control and at your own risk."
    )
    console.print("[dim]Scanning for Discord tokens...[/dim]")
    results = find_tokens()

    if not results:
        console.print("[red]No tokens found.[/red]")
        console.print(
            "[dim]Make sure Discord desktop app or browser is logged in.[/dim]"
        )
        return

    console.print(f"[dim]Found {len(results)} candidate token(s), validating...[/dim]")

    # Validate each token against the API
    valid_token = None
    valid_source = None
    user_info = None

    for r in results:
        token = r["token"]
        try:
            resp = httpx.get(
                "https://discord.com/api/v10/users/@me",
                headers={"Authorization": token},
                timeout=10.0,
            )
            if resp.status_code == 200:
                user_info = resp.json()
                valid_token = token
                valid_source = r["source"]
                break
        except Exception:
            continue

    if not valid_token or not user_info:
        console.print("[red]No valid token found. All tokens returned 401.[/red]")
        console.print("[dim]Try logging into Discord in your browser and retry.[/dim]")
        return

    masked = f"{valid_token[:8]}...{valid_token[-8:]}"
    username = user_info.get("username", "?")
    global_name = user_info.get("global_name") or username
    console.print(
        f"[green]✓[/green] Valid token from [cyan]{valid_source}[/cyan]: {masked}"
    )
    console.print(
        f"  Logged in as: [bold]{global_name}[/bold] (@{username})"
    )

    if save:
        env_path = save_token_to_env(valid_token)
        console.print(f"[green]✓[/green] Saved to {env_path}")
    else:
        console.print(
            "\n[dim]Run with --save to auto-save to .env[/dim]"
        )


@cli.command("status")
@structured_output_options
def status(as_json: bool, as_yaml: bool):
    """Check if Discord token is valid."""
    import sys

    import httpx

    from ..config import get_token
    from ..exceptions import NotAuthenticatedError

    try:
        token = get_token()
    except NotAuthenticatedError as e:
        if emit_structured(
            error_payload("not_authenticated", str(e)),
            as_json=as_json,
            as_yaml=as_yaml,
        ):
            sys.exit(1)
        console.print(f"[red]✗[/red] {e}")
        sys.exit(1)

    try:
        resp = httpx.get(
            "https://discord.com/api/v10/users/@me",
            headers={"Authorization": token},
            timeout=10.0,
        )
        if resp.status_code == 200:
            user = resp.json()
            payload = success_payload(
                {
                    "authenticated": True,
                    "user": _discord_user_payload(user),
                }
            )
            if emit_structured(payload, as_json=as_json, as_yaml=as_yaml):
                sys.exit(0)
            name = user.get("global_name") or user.get("username", "?")
            console.print(f"[green]✓[/green] Authenticated as [bold]{name}[/bold] (@{user.get('username')})")
            sys.exit(0)
        else:
            if emit_structured(
                error_payload(
                    "invalid_token",
                    f"Token invalid (HTTP {resp.status_code})",
                    details={"status_code": resp.status_code},
                ),
                as_json=as_json,
                as_yaml=as_yaml,
            ):
                sys.exit(1)
            console.print(f"[red]✗[/red] Token invalid (HTTP {resp.status_code})")
            sys.exit(1)
    except Exception as e:
        if emit_structured(
            error_payload("connection_error", str(e)),
            as_json=as_json,
            as_yaml=as_yaml,
        ):
            sys.exit(1)
        console.print(f"[red]✗[/red] Connection error: {e}")
        sys.exit(1)


@cli.command("whoami")
@structured_output_options
def whoami(as_json: bool, as_yaml: bool):
    """Show detailed profile of the current user."""
    import asyncio

    from ..client import get_client, get_me

    async def _run():
        async with get_client() as client:
            return await get_me(client)

    try:
        info = asyncio.run(_run())
    except Exception as exc:
        if emit_structured(error_payload("auth_error", str(exc)), as_json=as_json, as_yaml=as_yaml):
            raise SystemExit(1) from None
        raise click.ClickException(str(exc)) from exc

    if emit_structured(success_payload({"user": _discord_user_payload(info)}), as_json=as_json, as_yaml=as_yaml):
        return

    premium_names = {0: "None", 1: "Nitro Classic", 2: "Nitro", 3: "Nitro Basic"}
    table = Table(title="Discord Profile", show_header=False)
    table.add_column("Field", style="bold")
    table.add_column("Value")

    table.add_row("Username", f"@{info['username']}")
    if info.get("global_name"):
        table.add_row("Display Name", info["global_name"])
    table.add_row("ID", info["id"])
    if info.get("email"):
        table.add_row("Email", info["email"])
    if info.get("phone"):
        table.add_row("Phone", info["phone"])
    table.add_row("MFA", "✓" if info.get("mfa_enabled") else "✗")
    table.add_row("Nitro", premium_names.get(info.get("premium_type", 0), "?"))
    table.add_row("Created", info.get("created_at", "?")[:10])

    console.print(table)


# Register sub-groups
cli.add_command(discord_group, "dc")

# Register top-level query commands
for name, cmd in query_group.commands.items():
    cli.add_command(cmd, name)

# Register top-level data commands
for name, cmd in data_group.commands.items():
    cli.add_command(cmd, name)

"""Query commands — search, stats, today, top, timeline."""

from collections import defaultdict

import click
from rich.console import Console
from rich.table import Table

from ._channels import resolve_channel_id_or_raise
from ._output import emit_structured, structured_output_options
from ..db import MessageDB

console = Console(stderr=True)


@click.group("query", invoke_without_command=True)
def query_group():
    """Query and analysis commands (registered at top-level)."""
    pass


@query_group.command("search")
@click.argument("keyword")
@click.option("-c", "--channel", help="Filter by channel name")
@click.option("-n", "--limit", default=50, help="Max results")
@structured_output_options
def search(keyword: str, channel: str | None, limit: int, as_json: bool, as_yaml: bool):
    """Search stored messages by KEYWORD."""
    with MessageDB() as db:
        channel_id = resolve_channel_id_or_raise(db, channel) if channel else None
        results = db.search(keyword, channel_id=channel_id, limit=limit)

    if results and emit_structured(results, as_json=as_json, as_yaml=as_yaml):
        return

    if not results:
        if emit_structured([], as_json=as_json, as_yaml=as_yaml):
            return
        console.print("[yellow]No messages found.[/yellow]")
        return

    for msg in results:
        ts = (msg.get("timestamp") or "")[:19]
        sender = msg.get("sender_name") or "Unknown"
        ch_name = msg.get("channel_name") or ""
        content = (msg.get("content") or "")[:200]
        console.print(
            f"[dim]{ts}[/dim] [cyan]#{ch_name}[/cyan] | "
            f"[bold]{sender}[/bold]: {content}"
        )

    console.print(f"\n[dim]Found {len(results)} messages[/dim]")


@query_group.command("recent")
@click.option("-c", "--channel", help="Filter by channel name")
@click.option("--hours", type=int, help="Only show messages from last N hours")
@click.option("-n", "--limit", default=50, help="Show last N messages")
@structured_output_options
def recent(channel: str | None, hours: int | None, limit: int, as_json: bool, as_yaml: bool):
    """Show the most recent stored messages."""
    with MessageDB() as db:
        channel_id = resolve_channel_id_or_raise(db, channel) if channel else None
        results = db.get_latest(channel_id=channel_id, hours=hours, limit=limit)

    if results and emit_structured(results, as_json=as_json, as_yaml=as_yaml):
        return

    if not results:
        if emit_structured([], as_json=as_json, as_yaml=as_yaml):
            return
        console.print("[yellow]No recent messages found.[/yellow]")
        return

    show_channel = channel_id is None
    for msg in results:
        ts = (msg.get("timestamp") or "")[:19]
        sender = msg.get("sender_name") or "Unknown"
        ch_name = msg.get("channel_name") or ""
        content = (msg.get("content") or "")[:200].replace("\n", " ")
        prefix = f"[cyan]#{ch_name}[/cyan] | " if show_channel and ch_name else ""
        console.print(f"[dim]{ts}[/dim] {prefix}[bold]{sender}[/bold]: {content}")

    console.print(f"\n[dim]Showing {len(results)} recent messages[/dim]")


@query_group.command("stats")
@structured_output_options
def stats(as_json: bool, as_yaml: bool):
    """Show message statistics per channel."""
    with MessageDB() as db:
        channels = db.get_channels()
        total = db.count()

    payload = {"total": total, "channels": channels}
    if emit_structured(payload, as_json=as_json, as_yaml=as_yaml):
        return

    table = Table(title=f"Message Stats (Total: {total})")
    table.add_column("Channel ID", style="dim")
    table.add_column("Channel", style="bold")
    table.add_column("Guild", style="cyan")
    table.add_column("Messages", justify="right")
    table.add_column("First", style="dim")
    table.add_column("Last", style="dim")

    for c in channels:
        ch_id = str(c["channel_id"])
        table.add_row(
            ch_id[-6:] + "…" if len(ch_id) > 6 else ch_id,
            f"#{c['channel_name']}" if c["channel_name"] else "—",
            c.get("guild_name") or "—",
            str(c["msg_count"]),
            (c["first_msg"] or "")[:10],
            (c["last_msg"] or "")[:10],
        )

    console.print(table)


@query_group.command("today")
@click.option("-c", "--channel", help="Filter by channel name")
@structured_output_options
def today(channel: str | None, as_json: bool, as_yaml: bool):
    """Show today's messages, grouped by channel."""
    with MessageDB() as db:
        channel_id = resolve_channel_id_or_raise(db, channel) if channel else None
        msgs = db.get_today(channel_id=channel_id)

    if msgs and emit_structured(msgs, as_json=as_json, as_yaml=as_yaml):
        return

    if not msgs:
        if emit_structured([], as_json=as_json, as_yaml=as_yaml):
            return
        console.print("[yellow]No messages today.[/yellow]")
        return

    grouped: dict[str, list[dict]] = defaultdict(list)
    for m in msgs:
        key = f"#{m.get('channel_name') or 'unknown'}"
        if m.get("guild_name"):
            key = f"{m['guild_name']} > {key}"
        grouped[key].append(m)

    for ch_label, ch_msgs in sorted(grouped.items(), key=lambda x: -len(x[1])):
        console.print(f"\n[bold cyan]═══ {ch_label} ({len(ch_msgs)} msgs) ═══[/bold cyan]")
        for m in ch_msgs:
            ts = (m.get("timestamp") or "")[11:19]
            sender = m.get("sender_name") or "Unknown"
            content = (m.get("content") or "")[:200].replace("\n", " ")
            console.print(f"  [dim]{ts}[/dim] [bold]{sender[:15]}[/bold]: {content}")

    console.print(f"\n[green]Total: {len(msgs)} messages today[/green]")


@query_group.command("top")
@click.option("-c", "--channel", help="Filter by channel name")
@click.option("--hours", type=int, help="Only count messages within N hours")
@click.option("-n", "--limit", default=20, help="Top N senders")
@structured_output_options
def top(channel: str | None, hours: int | None, limit: int, as_json: bool, as_yaml: bool):
    """Show most active senders."""
    with MessageDB() as db:
        channel_id = resolve_channel_id_or_raise(db, channel) if channel else None
        results = db.top_senders(channel_id=channel_id, hours=hours, limit=limit)

    if results and emit_structured(results, as_json=as_json, as_yaml=as_yaml):
        return

    if not results:
        if emit_structured([], as_json=as_json, as_yaml=as_yaml):
            return
        console.print("[yellow]No sender data found.[/yellow]")
        return

    table = Table(title="Top Senders")
    table.add_column("#", style="dim", justify="right")
    table.add_column("Sender", style="bold")
    table.add_column("Messages", justify="right")
    table.add_column("First", style="dim")
    table.add_column("Last", style="dim")

    for i, r in enumerate(results, 1):
        table.add_row(
            str(i),
            r["sender_name"],
            str(r["msg_count"]),
            (r["first_msg"] or "")[:10],
            (r["last_msg"] or "")[:10],
        )

    console.print(table)


@query_group.command("timeline")
@click.option("-c", "--channel", help="Filter by channel name")
@click.option("--hours", type=int, help="Only show last N hours")
@click.option("--by", "granularity", type=click.Choice(["day", "hour"]), default="day")
@structured_output_options
def timeline(channel: str | None, hours: int | None, granularity: str, as_json: bool, as_yaml: bool):
    """Show message activity over time as a bar chart."""
    with MessageDB() as db:
        channel_id = resolve_channel_id_or_raise(db, channel) if channel else None
        results = db.timeline(channel_id=channel_id, hours=hours, granularity=granularity)

    if results and emit_structured(results, as_json=as_json, as_yaml=as_yaml):
        return

    if not results:
        if emit_structured([], as_json=as_json, as_yaml=as_yaml):
            return
        console.print("[yellow]No timeline data.[/yellow]")
        return

    max_count = max(r["msg_count"] for r in results)
    bar_width = 40

    for r in results:
        period = r["period"]
        count = r["msg_count"]
        bar_len = int(count / max_count * bar_width) if max_count > 0 else 0
        bar = "█" * bar_len
        console.print(f"[dim]{period}[/dim] {bar} [bold]{count}[/bold]")