kabi-discord-cli 0.1.0__tar.gz

kabi_discord_cli-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.egg-info/
+.venv/
+.env
+data/
+*.db
+.pytest_cache/
+dist/

kabi_discord_cli-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: kabi-discord-cli
+Version: 0.1.0
+Summary: Discord CLI — fetch chat history, search messages, daily sync
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13.0
+Provides-Extra: ai
+Requires-Dist: anthropic>=0.40; extra == 'ai'
+Provides-Extra: all
+Requires-Dist: anthropic>=0.40; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'

kabi_discord_cli-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "kabi-discord-cli"
+version = "0.1.0"
+description = "Discord CLI — fetch chat history, search messages, daily sync"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.27",
+    "click>=8.0",
+    "rich>=13.0",
+    "python-dotenv>=1.0",
+]
+
+[project.optional-dependencies]
+ai = ["anthropic>=0.40"]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.24"]
+all = ["kabi-discord-cli[ai]"]
+
+[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"]

kabi_discord_cli-0.1.0/src/discord_cli/__init__.py

@@ -0,0 +1,3 @@
+"""discord-cli — Discord CLI for fetching chat history."""
+
+__version__ = "0.1.0"

kabi_discord_cli-0.1.0/src/discord_cli/auth.py

@@ -0,0 +1,116 @@
+"""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}'),
+]
+
+# Encrypted token pattern (Discord client stores dQw4w9WgXcQ: encrypted)
+_ENCRYPTED_TOKEN_PATTERN = re.compile(r'dQw4w9WgXcQ:([^\s"]+)')
+
+
+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

kabi_discord_cli-0.1.0/src/discord_cli/cli/data.py

@@ -0,0 +1,84 @@
+"""Data commands — export, purge."""
+
+import json
+
+import click
+from rich.console import Console
+
+from ..db import MessageDB
+
+console = Console()
+
+
+@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"]), 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."""
+    db = MessageDB()
+    channel_id = db.resolve_channel_id(channel)
+
+    if channel_id is None:
+        console.print(f"[red]Channel '{channel}' not found in database.[/red]")
+        db.close()
+        return
+
+    if hours:
+        msgs = db.get_recent(channel_id=channel_id, hours=hours, limit=100000)
+    else:
+        msgs = db.get_recent(channel_id=channel_id, hours=None, limit=100000)
+    db.close()
+
+    if not msgs:
+        console.print(f"[yellow]No messages found for '{channel}'.[/yellow]")
+        return
+
+    if fmt == "json":
+        content = json.dumps(msgs, ensure_ascii=False, indent=2, default=str)
+    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."""
+    db = MessageDB()
+    channel_id = db.resolve_channel_id(channel)
+
+    if channel_id is None:
+        console.print(f"[red]Channel '{channel}' not found in database.[/red]")
+        db.close()
+        return
+
+    if not yes:
+        count = db.count(channel_id)
+        if not click.confirm(f"Delete {count} messages from channel {channel_id}?"):
+            db.close()
+            return
+
+    deleted = db.delete_channel(channel_id)
+    db.close()
+    console.print(f"[green]✓[/green] Deleted {deleted} messages")

kabi_discord_cli-0.1.0/src/discord_cli/cli/discord_cmds.py

@@ -0,0 +1,267 @@
+"""Discord subcommands — guilds, channels, history, sync, sync-all."""
+
+import asyncio
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from ..client import datetime_to_snowflake, fetch_messages, get_client, get_guild_info, list_channels, list_guilds
+from ..db import MessageDB
+
+console = Console()
+
+
+@click.group("dc")
+def discord_group():
+    """Discord operations — list servers, fetch history, sync."""
+    pass
+
+
+@discord_group.command("guilds")
+def dc_guilds():
+    """List joined Discord servers."""
+
+    async def _run():
+        async with get_client() as client:
+            return await list_guilds(client)
+
+    guilds = asyncio.run(_run())
+    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")
+def dc_channels(guild: str):
+    """List text channels in a GUILD (server ID or name)."""
+
+    async def _run():
+        async with get_client() as client:
+            # If guild looks like a name, search for it
+            guild_id = guild
+            if not guild.isdigit():
+                guilds = await list_guilds(client)
+                match = next(
+                    (g for g in guilds if guild.lower() in g["name"].lower()),
+                    None,
+                )
+                if not match:
+                    console.print(f"[red]Guild '{guild}' not found.[/red]")
+                    return []
+                guild_id = match["id"]
+                console.print(f"[dim]Resolved to: {match['name']} ({guild_id})[/dim]")
+
+            return await list_channels(client, guild_id)
+
+    channels = asyncio.run(_run())
+    if not channels:
+        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")
+def dc_history(channel: str, limit: int, guild_name: str | None, channel_name: str | None):
+    """Fetch historical messages from CHANNEL (channel ID)."""
+
+    async def _run():
+        db = MessageDB()
+        try:
+            async with get_client() as client:
+                # Try to get channel info for naming
+                ch_name = channel_name
+                g_name = guild_name
+
+                if not ch_name:
+                    try:
+                        ch_info = await client.get(f"/channels/{channel}")
+                        if ch_info.status_code == 200:
+                            ch_data = ch_info.json()
+                            ch_name = ch_data.get("name", channel)
+                            if not g_name and ch_data.get("guild_id"):
+                                g_info = await get_guild_info(client, ch_data["guild_id"])
+                                if g_info:
+                                    g_name = g_info["name"]
+                    except Exception:
+                        pass
+
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    console=console,
+                ) as progress:
+                    task = progress.add_task(f"Fetching messages from {ch_name or channel}...", total=None)
+
+                    messages = await fetch_messages(client, channel, limit=limit)
+                    progress.update(task, description=f"Fetched {len(messages)} messages")
+
+                # Enrich with guild/channel names
+                for msg in messages:
+                    msg["guild_name"] = g_name
+                    msg["channel_name"] = ch_name
+
+                inserted = db.insert_batch(messages)
+                return len(messages), inserted
+        finally:
+            db.close()
+
+    total, inserted = asyncio.run(_run())
+    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")
+def dc_sync(channel: str, limit: int):
+    """Incremental sync — fetch only new messages from CHANNEL."""
+    db = MessageDB()
+    last_id = db.get_last_msg_id(channel)
+    if last_id:
+        console.print(f"Syncing from msg_id > {last_id}...")
+
+    async def _run():
+        try:
+            async with get_client() as client:
+                # Get channel info
+                ch_name = None
+                g_name = None
+                try:
+                    ch_info = await client.get(f"/channels/{channel}")
+                    if ch_info.status_code == 200:
+                        ch_data = ch_info.json()
+                        ch_name = ch_data.get("name")
+                        if ch_data.get("guild_id"):
+                            g_info = await get_guild_info(client, ch_data["guild_id"])
+                            if g_info:
+                                g_name = g_info["name"]
+                except Exception:
+                    pass
+
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    console=console,
+                ) as progress:
+                    task_id = progress.add_task(f"Syncing {ch_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")
+
+                for msg in messages:
+                    msg["guild_name"] = g_name
+                    msg["channel_name"] = ch_name
+
+                inserted = db.insert_batch(messages)
+                return len(messages), inserted
+        finally:
+            db.close()
+
+    total, inserted = asyncio.run(_run())
+    console.print(f"\n[green]✓[/green] Synced {total} messages, stored {inserted} new")
+
+
+@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."""
+    db = MessageDB()
+    channels = db.get_channels()
+    if not channels:
+        console.print("[yellow]No channels in database. Run 'discord dc history' first.[/yellow]")
+        db.close()
+        return
+
+    console.print(f"Syncing {len(channels)} channels...")
+
+    async def _run():
+        try:
+            async with get_client() as client:
+                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
+                        )
+
+                        # Preserve existing names
+                        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
+        finally:
+            db.close()
+
+    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("info")
+@click.argument("guild")
+def dc_info(guild: str):
+    """Show detailed info about a GUILD (server)."""
+
+    async def _run():
+        async with get_client() as client:
+            return await get_guild_info(client, guild)
+
+    info = asyncio.run(_run())
+    if not info:
+        console.print(f"[red]Could not find guild: {guild}[/red]")
+        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)

kabi_discord_cli-0.1.0/src/discord_cli/cli/main.py

@@ -0,0 +1,95 @@
+"""discord-cli — CLI entry point."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from .data import data_group
+from .discord_cmds import discord_group
+from .query import query_group
+
+console = Console()
+
+
+@click.group()
+@click.version_option(package_name="discord-cli")
+def cli():
+    """discord — CLI for fetching Discord chat history and searching messages."""
+    pass
+
+
+@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("[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]"
+        )
+
+
+# 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)

kabi_discord_cli-0.1.0/src/discord_cli/cli/query.py

@@ -0,0 +1,120 @@
+"""Query commands — search, stats, today."""
+
+from collections import defaultdict
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ..db import MessageDB
+
+console = Console()
+
+
+@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")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def search(keyword: str, channel: str | None, limit: int, as_json: bool):
+    """Search messages by KEYWORD."""
+    import json
+
+    db = MessageDB()
+    channel_id = db.resolve_channel_id(channel) if channel else None
+    results = db.search(keyword, channel_id=channel_id, limit=limit)
+    db.close()
+
+    if not results:
+        console.print("[yellow]No messages found.[/yellow]")
+        return
+
+    if as_json:
+        console.print(json.dumps(results, ensure_ascii=False, indent=2, default=str))
+        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("stats")
+def stats():
+    """Show message statistics per channel."""
+    db = MessageDB()
+    channels = db.get_channels()
+    total = db.count()
+    db.close()
+
+    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:
+        table.add_row(
+            str(c["channel_id"])[-6:] + "…",
+            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")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def today(channel: str | None, as_json: bool):
+    """Show today's messages, grouped by channel."""
+    import json
+
+    db = MessageDB()
+    channel_id = db.resolve_channel_id(channel) if channel else None
+    msgs = db.get_today(channel_id=channel_id)
+    db.close()
+
+    if not msgs:
+        console.print("[yellow]No messages today.[/yellow]")
+        return
+
+    if as_json:
+        console.print(json.dumps(msgs, ensure_ascii=False, indent=2, default=str))
+        return
+
+    # Group by channel
+    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]")

kabi_discord_cli-0.1.0/src/discord_cli/client.py

@@ -0,0 +1,202 @@
+"""Discord REST API v10 client using httpx."""
+
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from typing import Any, AsyncGenerator
+
+import httpx
+
+from .config import API_BASE, get_token
+
+# Discord epoch: 2015-01-01T00:00:00Z
+DISCORD_EPOCH = 1420070400000
+
+
+def snowflake_to_datetime(snowflake: int | str) -> datetime:
+    """Convert a Discord snowflake ID to a UTC datetime."""
+    ms = (int(snowflake) >> 22) + DISCORD_EPOCH
+    return datetime.fromtimestamp(ms / 1000, tz=timezone.utc)
+
+
+def datetime_to_snowflake(dt: datetime) -> int:
+    """Convert a datetime to a Discord snowflake ID (for use as 'after' param)."""
+    ms = int(dt.timestamp() * 1000) - DISCORD_EPOCH
+    return ms << 22
+
+
+@asynccontextmanager
+async def get_client() -> AsyncGenerator[httpx.AsyncClient, None]:
+    """Async context manager for an authenticated httpx client."""
+    token = get_token()
+    async with httpx.AsyncClient(
+        base_url=API_BASE,
+        headers={
+            "Authorization": token,
+            "Content-Type": "application/json",
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+        },
+        timeout=30.0,
+    ) as client:
+        yield client
+
+
+async def _handle_rate_limit(response: httpx.Response) -> None:
+    """Sleep if we hit a rate limit."""
+    if response.status_code == 429:
+        data = response.json()
+        retry_after = data.get("retry_after", 1.0)
+        await asyncio.sleep(retry_after)
+    elif remaining := response.headers.get("X-RateLimit-Remaining"):
+        if int(remaining) == 0:
+            reset_after = float(response.headers.get("X-RateLimit-Reset-After", "1.0"))
+            await asyncio.sleep(reset_after)
+
+
+async def _get(client: httpx.AsyncClient, path: str, **params: Any) -> Any:
+    """GET request with rate limit handling and retry."""
+    for attempt in range(3):
+        response = await client.get(path, params=params)
+        if response.status_code == 429:
+            await _handle_rate_limit(response)
+            continue
+        await _handle_rate_limit(response)
+        response.raise_for_status()
+        return response.json()
+    raise RuntimeError(f"Rate limited after 3 retries: {path}")
+
+
+async def list_guilds(client: httpx.AsyncClient) -> list[dict]:
+    """List all guilds (servers) the user has joined."""
+    data = await _get(client, "/users/@me/guilds")
+    return [
+        {
+            "id": g["id"],
+            "name": g["name"],
+            "icon": g.get("icon"),
+            "owner": g.get("owner", False),
+        }
+        for g in data
+    ]
+
+
+async def list_channels(client: httpx.AsyncClient, guild_id: str) -> list[dict]:
+    """List all text channels in a guild."""
+    data = await _get(client, f"/guilds/{guild_id}/channels")
+    # type 0 = text channel, 5 = announcement, 15 = forum
+    text_types = {0, 5, 15}
+    results = []
+    for ch in data:
+        if ch.get("type") in text_types:
+            results.append(
+                {
+                    "id": ch["id"],
+                    "name": ch["name"],
+                    "type": ch.get("type", 0),
+                    "position": ch.get("position", 0),
+                    "parent_id": ch.get("parent_id"),
+                    "topic": ch.get("topic"),
+                }
+            )
+    return sorted(results, key=lambda x: x["position"])
+
+
+async def fetch_messages(
+    client: httpx.AsyncClient,
+    channel_id: str,
+    *,
+    limit: int = 1000,
+    after: str | None = None,
+    before: str | None = None,
+) -> list[dict]:
+    """Fetch messages from a channel, handling pagination.
+
+    Discord returns max 100 messages per request, so we paginate.
+    """
+    all_messages: list[dict] = []
+    remaining = limit
+
+    while remaining > 0:
+        batch_limit = min(remaining, 100)
+        params: dict[str, Any] = {"limit": batch_limit}
+        if after:
+            params["after"] = after
+
+        data = await _get(client, f"/channels/{channel_id}/messages", **params)
+
+        if not data:
+            break
+
+        for msg in data:
+            all_messages.append(_parse_message(msg, channel_id))
+
+        remaining -= len(data)
+
+        if len(data) < batch_limit:
+            break
+
+        # For pagination with 'after', we need to use the latest message ID.
+        # Discord returns messages newest first, so the last item is the oldest.
+        # When using 'after', we want to get messages AFTER a snowflake,
+        # and they come back newest-first. We move 'after' to the newest we've seen.
+        if after is not None:
+            # 'after' mode: messages come newest first, move forward
+            after = data[0]["id"]
+        else:
+            # Default: newest first, use 'before' to paginate backward
+            before = data[-1]["id"]
+            params.pop("after", None)
+            # Re-set for next iteration: we need to use 'before' instead
+            after = None
+
+        # Small delay to be nice
+        await asyncio.sleep(0.5)
+
+    # Sort by timestamp ascending
+    all_messages.sort(key=lambda m: m["msg_id"])
+    return all_messages
+
+
+def _parse_message(msg: dict, channel_id: str) -> dict:
+    """Parse a raw Discord message into our standard format."""
+    author = msg.get("author", {})
+    ts_str = msg.get("timestamp", "")
+    timestamp = datetime.fromisoformat(ts_str) if ts_str else datetime.now(timezone.utc)
+    if timestamp.tzinfo is None:
+        timestamp = timestamp.replace(tzinfo=timezone.utc)
+
+    # Build content: message text + any attachment URLs
+    content_parts = []
+    if msg.get("content"):
+        content_parts.append(msg["content"])
+    for att in msg.get("attachments", []):
+        content_parts.append(f"[attachment: {att.get('filename', 'file')}]")
+    for embed in msg.get("embeds", []):
+        if title := embed.get("title"):
+            content_parts.append(f"[embed: {title}]")
+
+    return {
+        "msg_id": msg["id"],
+        "channel_id": channel_id,
+        "sender_id": author.get("id"),
+        "sender_name": author.get("global_name") or author.get("username") or "Unknown",
+        "content": "\n".join(content_parts),
+        "timestamp": timestamp,
+    }
+
+
+async def get_guild_info(client: httpx.AsyncClient, guild_id: str) -> dict | None:
+    """Get detailed guild info."""
+    try:
+        data = await _get(client, f"/guilds/{guild_id}", with_counts="true")
+        return {
+            "id": data["id"],
+            "name": data["name"],
+            "description": data.get("description"),
+            "member_count": data.get("approximate_member_count"),
+            "online_count": data.get("approximate_presence_count"),
+        }
+    except Exception:
+        return None

kabi_discord_cli-0.1.0/src/discord_cli/config.py

@@ -0,0 +1,80 @@
+"""Configuration management - loads from .env or environment variables."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+def _load_env() -> None:
+    """Load .env from cwd first, then fall back to the source checkout."""
+    for candidate in (Path.cwd() / ".env", _PROJECT_ROOT / ".env"):
+        if candidate.is_file():
+            load_dotenv(candidate)
+            return
+
+
+def _default_data_home() -> Path:
+    """Return a platform-appropriate base directory for application data."""
+    if raw := os.environ.get("XDG_DATA_HOME", ""):
+        return Path(raw).expanduser()
+
+    home = Path.home()
+    if sys.platform == "darwin":
+        return home / "Library" / "Application Support"
+    if os.name == "nt":
+        local_appdata = os.environ.get("LOCALAPPDATA", "")
+        if local_appdata:
+            return Path(local_appdata).expanduser()
+        return home / "AppData" / "Local"
+    return home / ".local" / "share"
+
+
+def _resolve_env_path(raw: str) -> Path:
+    """Resolve user-provided paths relative to the current working directory."""
+    path = Path(raw).expanduser()
+    if not path.is_absolute():
+        path = Path.cwd() / path
+    return path
+
+
+_load_env()
+
+APP_NAME = "discord-cli"
+API_BASE = "https://discord.com/api/v10"
+
+
+def get_token() -> str:
+    val = os.environ.get("DISCORD_TOKEN", "")
+    if not val:
+        raise RuntimeError(
+            "DISCORD_TOKEN not set. Get it from browser DevTools → "
+            "Network tab → any Discord request → Authorization header."
+        )
+    return val
+
+
+def get_data_dir() -> Path:
+    """Return data directory, create if not exists."""
+    raw = os.environ.get("DATA_DIR", "")
+    if raw:
+        d = _resolve_env_path(raw)
+    else:
+        d = _default_data_home() / APP_NAME
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def get_db_path() -> Path:
+    raw = os.environ.get("DB_PATH", "")
+    if raw:
+        p = _resolve_env_path(raw)
+    else:
+        p = get_data_dir() / "messages.db"
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p

kabi_discord_cli-0.1.0/src/discord_cli/db.py

@@ -0,0 +1,237 @@
+"""SQLite database for storing Discord chat messages."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from .config import get_db_path
+
+_CREATE_TABLE = """
+CREATE TABLE IF NOT EXISTS messages (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    platform      TEXT    NOT NULL DEFAULT 'discord',
+    guild_id      TEXT,
+    guild_name    TEXT,
+    channel_id    TEXT    NOT NULL,
+    channel_name  TEXT,
+    msg_id        TEXT    NOT NULL,
+    sender_id     TEXT,
+    sender_name   TEXT,
+    content       TEXT,
+    timestamp     TEXT    NOT NULL,
+    raw_json      TEXT,
+    UNIQUE(platform, channel_id, msg_id)
+);
+"""
+
+_CREATE_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_messages_channel_ts ON messages(channel_id, timestamp);
+CREATE INDEX IF NOT EXISTS idx_messages_content ON messages(content);
+CREATE INDEX IF NOT EXISTS idx_messages_sender ON messages(sender_name);
+CREATE INDEX IF NOT EXISTS idx_messages_guild ON messages(guild_id);
+"""
+
+
+class MessageDB:
+    """SQLite message store with context manager support."""
+
+    def __init__(self, db_path: Path | str | None = None):
+        if db_path is None:
+            self.db_path = get_db_path()
+        else:
+            self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.conn = sqlite3.connect(str(self.db_path))
+        self.conn.row_factory = sqlite3.Row
+        self.conn.execute("PRAGMA journal_mode=WAL")
+        self.conn.executescript(_CREATE_TABLE + _CREATE_INDEX)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+    def insert_batch(self, messages: list[dict], platform: str = "discord") -> int:
+        """Batch insert messages. Returns rows actually inserted (excluding dupes)."""
+        if not messages:
+            return 0
+        rows = [
+            (
+                platform,
+                m.get("guild_id"),
+                m.get("guild_name"),
+                m["channel_id"],
+                m.get("channel_name"),
+                m["msg_id"],
+                m.get("sender_id"),
+                m.get("sender_name"),
+                m.get("content"),
+                m["timestamp"].isoformat() if isinstance(m["timestamp"], datetime) else m["timestamp"],
+                json.dumps(m["raw_json"], ensure_ascii=False) if m.get("raw_json") else None,
+            )
+            for m in messages
+        ]
+        try:
+            before = self.conn.total_changes
+            self.conn.executemany(
+                """INSERT OR IGNORE INTO messages
+                   (platform, guild_id, guild_name, channel_id, channel_name,
+                    msg_id, sender_id, sender_name, content, timestamp, raw_json)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                rows,
+            )
+            self.conn.commit()
+            return self.conn.total_changes - before
+        except sqlite3.Error:
+            return 0
+
+    def resolve_channel_id(self, channel_str: str) -> str | None:
+        """Resolve a channel string (name or ID) to a database channel_id."""
+        channels = self.get_channels()
+
+        # Try name match first
+        for c in channels:
+            if c["channel_name"] and channel_str.lower() in c["channel_name"].lower():
+                return c["channel_id"]
+
+        # Try raw ID
+        for c in channels:
+            if c["channel_id"] == channel_str:
+                return c["channel_id"]
+
+        return channel_str  # Return as-is, might be a valid ID
+
+    def search(
+        self,
+        keyword: str,
+        channel_id: str | None = None,
+        limit: int = 50,
+    ) -> list[dict]:
+        """Search messages by keyword."""
+        query = "SELECT * FROM messages WHERE content LIKE ?"
+        params: list[Any] = [f"%{keyword}%"]
+        if channel_id:
+            query += " AND channel_id = ?"
+            params.append(channel_id)
+        query += " ORDER BY timestamp DESC LIMIT ?"
+        params.append(limit)
+        rows = self.conn.execute(query, params).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_recent(
+        self,
+        channel_id: str | None = None,
+        hours: int | None = 24,
+        limit: int = 500,
+    ) -> list[dict]:
+        """Get recent messages. If hours is None, return all."""
+        if hours is not None:
+            cutoff = (datetime.now(timezone.utc) - timedelta(hours=hours)).isoformat()
+            query = "SELECT * FROM messages WHERE timestamp >= ?"
+            params: list[Any] = [cutoff]
+        else:
+            query = "SELECT * FROM messages WHERE 1=1"
+            params = []
+        if channel_id:
+            query += " AND channel_id = ?"
+            params.append(channel_id)
+        query += " ORDER BY timestamp ASC LIMIT ?"
+        params.append(limit)
+        rows = self.conn.execute(query, params).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_today(
+        self,
+        channel_id: str | None = None,
+        tz_offset_hours: int = 8,
+        limit: int = 5000,
+    ) -> list[dict]:
+        """Get today's messages (in local timezone)."""
+        now_utc = datetime.now(timezone.utc)
+        local_tz = timezone(timedelta(hours=tz_offset_hours))
+        today_local = now_utc.astimezone(local_tz).replace(hour=0, minute=0, second=0, microsecond=0)
+        cutoff_utc = today_local.astimezone(timezone.utc).isoformat()
+
+        query = "SELECT * FROM messages WHERE timestamp >= ?"
+        params: list[Any] = [cutoff_utc]
+        if channel_id:
+            query += " AND channel_id = ?"
+            params.append(channel_id)
+        query += " ORDER BY channel_name, timestamp ASC LIMIT ?"
+        params.append(limit)
+        rows = self.conn.execute(query, params).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_channels(self) -> list[dict]:
+        """Get all known channels with message counts."""
+        rows = self.conn.execute(
+            """SELECT channel_id, channel_name, guild_id, guild_name,
+                      COUNT(*) as msg_count,
+                      MIN(timestamp) as first_msg, MAX(timestamp) as last_msg
+               FROM messages
+               GROUP BY channel_id
+               ORDER BY msg_count DESC"""
+        ).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_last_msg_id(self, channel_id: str) -> str | None:
+        """Get the latest msg_id for a channel, used for incremental sync."""
+        row = self.conn.execute(
+            "SELECT MAX(msg_id) FROM messages WHERE channel_id = ?", (channel_id,)
+        ).fetchone()
+        return row[0] if row and row[0] is not None else None
+
+    def count(self, channel_id: str | None = None) -> int:
+        if channel_id:
+            row = self.conn.execute(
+                "SELECT COUNT(*) FROM messages WHERE channel_id = ?", (channel_id,)
+            ).fetchone()
+        else:
+            row = self.conn.execute("SELECT COUNT(*) FROM messages").fetchone()
+        return row[0]
+
+    def delete_channel(self, channel_id: str) -> int:
+        """Delete all messages for a channel. Returns number of deleted rows."""
+        cursor = self.conn.execute(
+            "DELETE FROM messages WHERE channel_id = ?", (channel_id,)
+        )
+        self.conn.commit()
+        return cursor.rowcount
+
+    def top_senders(
+        self,
+        channel_id: str | None = None,
+        hours: int | None = None,
+        limit: int = 20,
+    ) -> list[dict]:
+        """Get most active senders."""
+        conditions = ["sender_name IS NOT NULL"]
+        params: list[Any] = []
+        if channel_id:
+            conditions.append("channel_id = ?")
+            params.append(channel_id)
+        if hours:
+            cutoff = (datetime.now(timezone.utc) - timedelta(hours=hours)).isoformat()
+            conditions.append("timestamp >= ?")
+            params.append(cutoff)
+
+        where = " AND ".join(conditions)
+        rows = self.conn.execute(
+            f"""SELECT sender_name, sender_id, COUNT(*) as msg_count,
+                       MIN(timestamp) as first_msg, MAX(timestamp) as last_msg
+                FROM messages WHERE {where}
+                GROUP BY sender_name
+                ORDER BY msg_count DESC
+                LIMIT ?""",
+            params + [limit],
+        ).fetchall()
+        return [dict(r) for r in rows]
+
+    def close(self):
+        self.conn.close()