tg2llm 0.1.0__tar.gz

tg2llm-0.1.0/.env.example

@@ -0,0 +1,5 @@
+# Copy to .env and fill in from https://my.telegram.org (API development tools)
+TG_API_ID=
+TG_API_HASH=
+# Optional: custom session file location (default: ~/.config/tg-sort/session)
+# TG_SESSION=

tg2llm-0.1.0/.gitignore

@@ -0,0 +1,223 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi/*
+!.pixi/config.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule*
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore that
+#   can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, you
+#   could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Telethon session files (= full account access)
+*.session

tg2llm-0.1.0/AGENTS.md

@@ -0,0 +1,73 @@
+# AGENTS.md
+
+## Project Overview
+
+`tg` is a single-file Python CLI (`tg.py`, ~340 lines) that exposes a Telegram **user account** via MTProto (Telethon) so an AI agent can inventory chats/contacts, read recent messages, and sort chats into folders. All output is JSON; all write paths are additive and dry-runnable. There is deliberately no framework, no package layout, no second module.
+
+## Setup Commands
+
+```bash
+make setup     # uv sync — creates .venv, installs telethon + pytest
+make install   # system-wide binary via `uv tool install .` (project.scripts: tg = "tg:main")
+```
+
+Credentials: `cp .env.example .env` and fill `TG_API_ID`/`TG_API_HASH` (from my.telegram.org). The Makefile auto-exports `.env`. Live login is interactive and human-only: `make auth` (session lands in `~/.config/tg-sort/session`). Without credentials/login every command exits fast with a JSON error — that is by design, not a bug.
+
+## Verification Gate
+
+Every change must pass:
+
+```bash
+make check     # ruff check + pytest, in that order
+```
+
+No CI exists yet; the gate is local only.
+
+## Testing Instructions
+
+- Run all: `make test` (or `uv run pytest -q`)
+- Single test: `uv run pytest -q test_tg.py::test_move_adds_peer_additively`
+- Tests are **offline by design**: pure helpers are exercised directly, and `move_chat()` runs against `FakeClient` (records every request; returns canned filters). Never add a test that needs a real session or network.
+- New write-path logic (folder mutation, archive, anything sending a request) must get a `--dry-run`-style test asserting **zero requests sent**, plus a happy-path test asserting the exact request type (`functions.messages.UpdateDialogFilterRequest`).
+- TDD: write the failing test first, watch it fail, then implement.
+
+## Code Style
+
+- Stdlib only for the CLI (`argparse`, `asyncio`, `contextlib`, `json`). Telethon is the only runtime dependency.
+- One file. Do not split `tg.py` into a package unless it hurts.
+- No comments unless asked; function/variable names carry the meaning.
+- Structure to preserve, top to bottom: constants → `CliError` → output/transport helpers (`out`, `call`, `session`) → pure helpers (`unwrap_filters`, `filter_title`, `find_filter`, `next_filter_id`, `new_filter`, `folder_membership`, `chat_row`, `parse_chat`) → `move_chat` → command handlers → `main()`.
+- Pure helpers must stay Telethon-importable-but-callable without a client — that's what makes them testable.
+- Errors: raise `CliError` with a message; `main()` turns it into `{"error": ...}` + exit 1. Never `sys.exit` deep in helpers.
+
+## Build / Install
+
+`uv tool install --upgrade .` builds a wheel (hatchling, `only-include = ["tg.py"]` — flat module, this flag is load-bearing) and links `~/.local/bin/tg`. Rerun after any `tg.py` change for the installed binary to pick it up. Package name is `tg2llm` (avoids PyPI collision with GramJS's `telegram`).
+
+## Telethon Gotchas (the load-bearing knowledge)
+
+1. **`async with client` calls `start()`**, which prompts interactively on stdin when unauthorized — an agent process hangs forever. All non-auth commands use the `session()` contextmanager: `connect()` → `is_user_authorized()` check → fail fast. Only `cmd_auth` may call `start()`.
+2. **Name collision:** `types.UpdateDialogFilter` is an _update event_; the request is `functions.messages.UpdateDialogFilterRequest`. Wrong namespace = isinstance checks silently fail.
+3. **Folder titles are `TextWithEntities`** (Folders 2.0), not strings. Always extract text via `filter_title()`; when constructing, pass `types.TextPlain(title)`. Server rejects full-filter updates that drop fields — send the whole `DialogFilter` back, not a partial.
+4. **Folders are saved views, not containers**: membership = presence in `DialogFilter.include_peers`. "Move" is additive append + `UpdateDialogFilterRequest(id, filter)`. Chats may legitimately live in multiple folders.
+5. **IDs are marked**: users positive, groups negative, channels/supergroups `-100…`. Compare with `telethon.utils.get_peer_id()` on both sides before any equality check.
+6. **API drift defense:** `unwrap_filters()` handles both a bare filter list and a wrapper exposing `.filters` — keep it that way when touching folder code.
+7. FloodWait: all requests go through `call()` which sleeps `e.seconds + 1` and retries once. Don't bypass it.
+
+## LSP Noise
+
+The editor reports ~8 type errors in `tg.py` (TextPlain assignability, `start()`/`get_me()` return types, `reversed()` on TotalList). These are Telethon stub-inference gaps, runtime-verified by the test suite. Suppress with narrow `# type: ignore[union-attr]` comments like the tests do — do not "fix" them by restructuring working code.
+
+## Debugging
+
+- Smoke path after changes: `./tg --help`, then `tg chats` against a real session.
+- `tg move <chat> --to <folder> --dry-run` is the safe probe for folder logic.
+- Session file `~/.config/tg-sort/session` is the account credential — never read, copy, or commit it; `*.session` is gitignored.
+- To test against a scratch account: `TG_SESSION=~/.config/tg-sort/session-test` isolates the session.
+
+## PR / Change Checklist
+
+- `make check` green (lint errors are fixed, never skipped — no "pre-existing" excuses)
+- New logic got a failing-test-first pass
+- Write paths: dry-run test included, request counts asserted
+- README updated if the CLI surface, env vars, or limits changed

tg2llm-0.1.0/Makefile

@@ -0,0 +1,35 @@
+.PHONY: help setup install uninstall auth test lint fmt check clean
+
+-include .env
+export
+
+UV ?= uv
+
+help: ## Show available targets
+	@grep -E '^[a-zA-Z_-]+:.*?## ' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-10s\033[0m %s\n", $$1, $$2}'
+
+setup: ## Install dependencies into .venv (uv sync)
+	$(UV) sync
+
+install: ## Install tg system-wide via uv tool
+	$(UV) tool install --upgrade .
+
+uninstall: ## Remove system-wide tg
+	$(UV) tool uninstall tg2llm
+
+auth: ## One-time interactive Telegram login
+	$(UV) run python tg.py auth
+
+test: ## Run test suite
+	$(UV) run pytest -q
+
+lint: ## Run ruff checks
+	ruff check tg.py test_tg.py
+
+fmt: ## Ruff autofix
+	ruff check --fix tg.py test_tg.py
+
+check: lint test ## Everything a change must pass
+
+clean: ## Remove caches
+	rm -rf .pytest_cache .ruff_cache __pycache__

tg2llm-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.5
+Name: tg2llm
+Version: 0.1.0
+Requires-Python: >=3.12
+Requires-Dist: telethon>=1.45.0

tg2llm-0.1.0/README.md

@@ -0,0 +1,285 @@
+# tg — Telegram sorting CLI for AI agents
+
+`tg` is a single-file Python CLI that exposes a **Telegram user account** to AI agents (or humans): it lists contacts, chats and folders, reads recent messages, and sorts chats into folders. All output is JSON on stdout, all errors are JSON on stderr with a non-zero exit code — built to be shell-scripted by an agent loop:
+
+```
+tg chats  →  tg read <chat>  →  tg move <chat> --to <folder>
+```
+
+> [!IMPORTANT]
+> This talks **MTProto as your own user account**, not the Bot API. Bots cannot see your contacts, your dialog list, or your folders — a user session is the only way this tool can exist. Automating your own account for reading/organizing is tolerated by Telegram; spamming is not.
+
+## Key features
+
+- **Inventory** — all dialogs with type, unread count, folder memberships, archive state and last-message preview in one call
+- **Read** — recent messages of any chat (the classification input for your agent)
+- **Folders** — list, create, and add chats to folders (additive; a chat may live in several folders)
+- **Archive** — one call to archive/unarchive a chat
+- **Agent-proof** — JSON everywhere, `--dry-run` on writes, FloodWait auto-retry, no interactive prompts unless you ask for them
+
+## Tech stack
+
+- **Language**: Python 3.12+
+- **Telegram**: [Telethon 1.45](https://docs.telethon.dev/) (MTProto client library)
+- **Packaging**: [uv](https://docs.astral.sh/uv/) + hatchling
+- **Tests**: pytest (pure-logic tests against fake clients — no network)
+- **Lint**: ruff
+- **CLI**: stdlib `argparse`, zero other runtime deps
+
+## Prerequisites
+
+- Python 3.12+ and [uv](https://docs.astral.sh/uv/getting_started/install/)
+- A Telegram account
+- An `api_id` / `api_hash` pair — create once at [my.telegram.org](https://my.telegram.org) → _API development tools_
+
+## Getting started (clone → using)
+
+```bash
+git clone <this-repo> && cd Telegram
+
+# 1. install deps into .venv
+make setup
+
+# 2. configure credentials
+cp .env.example .env      # then edit: TG_API_ID, TG_API_HASH
+
+# 3. one-time interactive login (phone + code + optional 2FA)
+make auth
+
+# 4. optional: install system-wide so `tg` works from anywhere
+make install
+
+# 5. use it
+tg chats
+```
+
+The login in step 3 creates a session file at `~/.config/tg-sort/session` — after that, no more prompts, ever.
+
+> [!WARNING]
+> The session file **is** your Telegram account. Anyone who can read it can act as you. Keep it where it is, never commit/copy it (`*.session` is already gitignored).
+
+<details>
+<summary>No Makefile? Plain commands</summary>
+
+```bash
+uv sync                                   # deps
+cp .env.example .env                      # edit credentials
+export $(grep -v '^#' .env | xargs)       # or export manually
+uv run python tg.py auth                  # login
+uv tool install .                         # system-wide
+```
+
+</details>
+
+## Make targets
+
+| Target           | What it does                                  |
+| ---------------- | --------------------------------------------- |
+| `make setup`     | `uv sync` — create/refresh `.venv`            |
+| `make auth`      | One-time interactive login                    |
+| `make install`   | Install `tg` system-wide (`uv tool install`)  |
+| `make uninstall` | Remove the system-wide binary                 |
+| `make test`      | Run the test suite                            |
+| `make lint`      | ruff checks                                   |
+| `make fmt`       | ruff autofix                                  |
+| `make check`     | lint + test — the gate every change must pass |
+| `make clean`     | Remove caches                                 |
+
+The Makefile loads `.env` automatically, so `make auth` picks up your credentials without exporting anything.
+
+## CLI reference
+
+Every command prints JSON (stdout, `indent=1`). Errors print `{"error": "..."}` to stderr and exit `1`.
+
+### `tg prime`
+
+Prints the embedded agent skill: command reference, safety rules (writes require human confirmation + dry-run first), the sort workflow, and an example session. Feed this to your agent once and it knows how to drive the tool:
+
+```bash
+tg prime > /tmp/tg-skill.md
+```
+
+### `tg auth`
+
+One-time interactive login. Prompts for phone number, login code, and 2FA password if set. Prints the logged-in user. Run this once per machine.
+
+### `tg contacts`
+
+```json
+[
+  {
+    "id": 123456789,
+    "name": "Jane Doe",
+    "username": "janedoe",
+    "phone": "4915012345678"
+  }
+]
+```
+
+### `tg chats [--folder NAME] [--limit N]`
+
+All dialogs with folder memberships (from `--folder`, filtered client-side). This is the agent's inventory.
+
+```json
+[
+  {
+    "id": -1001701234567,
+    "title": "Solana News",
+    "type": "channel",
+    "unread": 42,
+    "folders": ["Crypto"],
+    "archived": false,
+    "last_message": {
+      "date": "2026-09-17 09:12:00+00:00",
+      "text": "Mainnet upgrade shipped —"
+    }
+  }
+]
+```
+
+IDs are _marked_ peer IDs (negative for groups/channels) — pass them back verbatim to `read`/`move`/`archive`.
+
+### `tg read CHAT [--last N]` (default 20)
+
+Recent messages of a chat, oldest first.
+
+```json
+[
+  {
+    "id": 4812,
+    "date": "2026-09-17 08:59:00+00:00",
+    "sender_id": 987654321,
+    "text": "deploy blocked on the audit, moving to Friday"
+  }
+]
+```
+
+### `tg folders`
+
+```json
+[
+  {
+    "id": 5,
+    "title": "Crypto",
+    "emoticon": null,
+    "chats": [-1001701234567, -1009876543210]
+  }
+]
+```
+
+### `tg create-folder TITLE [--chat CHAT]`
+
+Creates a folder (`TITLE` ≤ 12 chars, max 10 folders — Telegram's limits), optionally seeded with one chat.
+
+### `tg move CHAT --to FOLDER [--create] [--dry-run]`
+
+Adds a chat to a folder, **additively** — other folder memberships stay untouched. `FOLDER` is matched case-insensitively by title or by id. `--create` creates the folder if missing. `--dry-run` computes and prints the diff without sending anything.
+
+```json
+{
+  "chat": -1001701234567,
+  "folder": { "id": 6, "title": "AI News" },
+  "action": "added",
+  "dry_run": false,
+  "include_count": { "before": 3, "after": 4 }
+}
+```
+
+`action` is `"added"`, `"created+added"`, or `"already"` (idempotent, sends nothing).
+
+### `tg archive CHAT [--undo]`
+
+Moves a chat to the archive folder (or back with `--undo`).
+
+## The agent sorting loop
+
+```bash
+tg chats                                   # 1. inventory + current folders
+tg read -1001701234567 --last 20           # 2. inspect an unsorted chat
+tg move -1001701234567 --to "AI News" --dry-run   # 3. preview
+tg move -1001701234567 --to "AI News" --create    # 4. apply (creates folder if needed)
+```
+
+Recommended agent policy: dry-run first, batch many moves per run, sleep briefly between calls to stay far away from rate limits.
+
+## Environment variables
+
+| Variable      | Required | Default                     | Purpose                       |
+| ------------- | -------- | --------------------------- | ----------------------------- |
+| `TG_API_ID`   | yes      | —                           | API id from my.telegram.org   |
+| `TG_API_HASH` | yes      | —                           | API hash from my.telegram.org |
+| `TG_SESSION`  | no       | `~/.config/tg-sort/session` | Telethon session file path    |
+
+## Architecture
+
+### Project layout
+
+```
+├── tg.py        # everything: CLI, Telethon plumbing, pure helpers
+├── test_tg.py   # pytest suite, FakeClient-based — no network
+├── tg           # dev wrapper: .venv python on tg.py (symlink-free)
+├── Makefile     # setup / auth / install / test / lint targets
+├── pyproject.toml  # uv + hatchling; [project.scripts] tg = "tg:main"
+└── .env.example
+```
+
+### How folder sorting actually works
+
+Telegram folders ("dialog filters") are **saved views, not containers**. A folder is a `DialogFilter` object: rule flags (all groups / all unmuted / …) plus explicit `include_peers` / `exclude_peers` lists. Adding a chat to a folder means:
+
+1. fetch all filters — `messages.GetDialogFiltersRequest`
+2. locate the target folder (by id or title)
+3. append the chat's `InputPeer` to `include_peers`
+4. send the whole filter back — `messages.UpdateDialogFilterRequest(id, filter)`
+
+Because folders are views, a chat can be in several at once — that's why `move` is additive by design. Exclusive sorting would mean removing the peer from every other filter's `include_peers` first.
+
+### Key pieces in `tg.py`
+
+| Piece                   | Why it exists                                                                                                                                                                                                                     |
+| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `session()` ctx manager | `async with client` in Telethon calls `start()`, which **prompts interactively** if unauthorized — this would hang an agent. `session()` connects, checks `is_user_authorized()`, and fails fast with a clean JSON error instead. |
+| `call()` wrapper        | Catches `FloodWaitError`, sleeps the requested seconds, retries once                                                                                                                                                              |
+| `filter_title()`        | Folder titles are `TextWithEntities` since Folders 2.0 — helper extracts the plain text                                                                                                                                           |
+| `unwrap_filters()`      | Different API layers return either a bare list or a wrapper with `.filters` — handled once here                                                                                                                                   |
+| `find_filter()`         | Case-insensitive title match _or_ numeric id match                                                                                                                                                                                |
+| `move_chat()`           | The whole sort primitive: resolve entity → locate folder → idempotency check → append peer → send. Pure enough to test against a fake client.                                                                                     |
+
+### Limits enforced (Telegram's, not ours)
+
+- 10 folders max, folder titles ≤ 12 chars
+- Marked IDs: users are positive ints, groups `-…`, channels/supergroups `-100…`
+
+## Testing
+
+```bash
+make test          # 15 tests
+uv run pytest -q test_tg.py::test_move_dry_run_no_call   # single test
+```
+
+The suite covers the pure helpers (filter lookup, title extraction, id allocation, membership) and the `move_chat` primitive against a `FakeClient` that records requests — no network, no account needed. The Telethon I/O shell is verified by the smoke path: `tg chats` on a real session.
+
+## Troubleshooting
+
+| Symptom                                         | Fix                                                                                                                                    |
+| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `{"error": "set TG_API_ID and TG_API_HASH..."}` | `cp .env.example .env`, fill in values; export them in shells that don't go through the Makefile                                       |
+| `{"error": "not logged in - run: ./tg auth"}`   | Session missing/expired on this machine — `make auth`                                                                                  |
+| Command hangs forever                           | You're probably calling `tg auth` from a non-interactive context. `auth` is the only command that prompts; run it once from a terminal |
+| `FloodWaitError` in output                      | The wrapper retries once automatically; if you still see it, slow the agent loop down (sleep between moves)                            |
+| `tg: command not found` after `make install`    | `~/.local/bin` not on `PATH` — add `export PATH="$HOME/.local/bin:$PATH"`                                                              |
+| Updates not picked up after code changes        | `make install` runs `uv tool install --upgrade .` — rerun it                                                                           |
+| Login SMS never arrives                         | Try login code via Telegram app (option appears after the phone step)                                                                  |
+
+## Security notes
+
+- `.env` and session files are gitignored; the session grants full account access — treat it like a password
+- The tool only ever _reads_ chats and _edits your own folder/archive state_. It never sends messages, so it cannot spam on your behalf
+- Revoking access: Telegram → Settings → Devices → terminate the session (then delete `~/.config/tg-sort/session`)
+
+## Uninstall
+
+```bash
+make uninstall   # removes the system-wide binary
+rm -rf ~/.config/tg-sort   # session + credentials cache
+```

tg2llm-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "tg2llm"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+    "telethon>=1.45.0",
+]
+
+[project.scripts]
+tg = "tg:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["tg.py"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

tg2llm-0.1.0/test_tg.py

@@ -0,0 +1,160 @@
+import asyncio
+
+from telethon import functions, types, utils
+
+import tg
+
+IPU = types.InputPeerUser
+
+
+def mkfilter(fid, title, include=()):
+    return types.DialogFilter(
+        id=fid,
+        title=title,
+        pinned_peers=[],
+        include_peers=list(include),
+        exclude_peers=[],
+    )
+
+
+class FakeClient:
+    def __init__(self, filters):
+        self.filters = filters
+        self.calls = []
+
+    async def get_entity(self, chat_id):
+        return types.User(id=42, access_hash=7)
+
+    async def __call__(self, request):
+        self.calls.append(request)
+        return self.filters
+
+
+def run(coro):
+    return asyncio.run(coro)
+
+
+def updates(c):
+    return [
+        r
+        for r in c.calls
+        if isinstance(r, functions.messages.UpdateDialogFilterRequest)
+    ]
+
+
+# --- unwrap_filters ---------------------------------------------------------
+
+
+def test_unwrap_filters_vector():
+    fs = [mkfilter(2, types.TextPlain("a")), types.DialogFilterDefault()]
+    assert tg.unwrap_filters(fs) == fs
+
+
+def test_unwrap_filters_wrapper():
+    class W:
+        filters = ["x"]
+
+    assert tg.unwrap_filters(W()) == ["x"]
+
+
+# --- titles / lookup --------------------------------------------------------
+
+
+def test_filter_title_text_with_entities():
+    assert tg.filter_title(mkfilter(2, types.TextPlain("News"))) == "News"
+
+
+def test_filter_title_plain_str_fallback():
+    assert tg.filter_title(mkfilter(2, "Raw")) == "Raw"
+
+
+def test_find_filter_by_name_case_insensitive():
+    fs = [types.DialogFilterDefault(), mkfilter(5, types.TextPlain("News"))]
+    assert tg.find_filter(fs, "news").id == 5  # type: ignore[union-attr]
+
+
+def test_find_filter_by_id_string():
+    fs = [mkfilter(5, types.TextPlain("News"))]
+    assert tg.find_filter(fs, "5").id == 5  # type: ignore[union-attr]
+
+
+def test_find_filter_missing_returns_none():
+    assert tg.find_filter([mkfilter(5, types.TextPlain("News"))], "work") is None
+
+
+def test_next_filter_id():
+    assert tg.next_filter_id([]) == 2
+    assert tg.next_filter_id([mkfilter(2, "a"), mkfilter(5, "b")]) == 6
+
+
+# --- membership / move ------------------------------------------------------
+
+
+def test_folder_membership_map():
+    fs = [mkfilter(5, types.TextPlain("News"), include=[IPU(user_id=1, access_hash=0)])]
+    mem = tg.folder_membership(fs)
+    assert mem[1] == ["News"]
+
+
+def test_move_adds_peer_additively():
+    f = mkfilter(5, types.TextPlain("News"), include=[IPU(user_id=1, access_hash=0)])
+    c = FakeClient([f])
+    res = run(tg.move_chat(c, 42, "news"))
+    assert res["action"] == "added"
+    assert len(updates(c)) == 1
+    assert utils.get_peer_id(f.include_peers[1]) == 42
+    assert tg.filter_title(f) == "News"  # untouched
+
+
+def test_move_already_member_no_call():
+    f = mkfilter(5, types.TextPlain("News"), include=[IPU(user_id=42, access_hash=7)])
+    c = FakeClient([f])
+    res = run(tg.move_chat(c, 42, "news"))
+    assert res["action"] == "already"
+    assert updates(c) == []
+
+
+def test_move_dry_run_no_call():
+    f = mkfilter(5, types.TextPlain("News"))
+    c = FakeClient([f])
+    res = run(tg.move_chat(c, 42, "news", dry=True))
+    assert res["action"] == "added" and res["dry_run"] is True
+    assert updates(c) == []
+
+
+def test_move_creates_folder_with_flag():
+    c = FakeClient([])
+    res = run(tg.move_chat(c, 42, "work", create=True))
+    assert res["action"] == "created+added"
+    assert len(updates(c)) == 1
+    sent = updates(c)[0]
+    assert sent.id == 2 and len(sent.filter.include_peers) == 1  # type: ignore[union-attr]
+
+
+def test_move_missing_folder_raises():
+    c = FakeClient([])
+    try:
+        run(tg.move_chat(c, 42, "work"))
+        raise AssertionError("expected CliError")
+    except tg.CliError:
+        pass
+
+
+def test_new_folder_title_limit():
+    try:
+        tg.new_filter(3, "x" * 13)
+        raise AssertionError("expected CliError")
+    except tg.CliError:
+        pass
+
+
+# --- prime skill ------------------------------------------------------------
+
+
+def test_prime_skill_safety_rules_present():
+    low = tg.PRIME.lower()
+    assert "never send a write command without human confirmation" in low
+    assert "dry-run" in low and "explicit ok" in low
+    for cmd in ("chats", "read", "contacts", "folders", "create-folder", "move", "archive"):
+        assert cmd in tg.PRIME
+    assert tg.PRIME.startswith("# tg")

tg2llm-0.1.0/tg

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+DIR="$(cd "$(dirname "$(readlink -f "$0")")" && pwd)"
+exec "$DIR/.venv/bin/python" "$DIR/tg.py" "$@"

tg2llm-0.1.0/tg.py

@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+"""tg - Telegram user-account CLI for agents. JSON out.
+
+Env: TG_API_ID, TG_API_HASH (https://my.telegram.org), TG_SESSION (optional).
+"""
+import argparse
+import asyncio
+import contextlib
+import json
+import os
+import sys
+
+from telethon import TelegramClient, functions, types, utils
+from telethon.errors import FloodWaitError
+
+ARCHIVE_ID = 1
+MAX_FOLDERS = 10
+MAX_TITLE = 12
+API_ID = int(os.environ.get("TG_API_ID", "0") or 0)
+API_HASH = os.environ.get("TG_API_HASH", "")
+SESSION = os.environ.get(
+    "TG_SESSION", os.path.expanduser("~/.config/tg-sort/session")
+)
+
+PRIME = """\
+# tg — Telegram folder-sorting skill
+
+CLI over a Telegram USER account (MTProto). Reads chats/contacts, sorts chats
+into folders. JSON on stdout; errors {"error": ...} on stderr, exit 1.
+
+## Safety rules (MANDATORY)
+
+- Write commands are: create-folder, move (without --dry-run), archive.
+- NEVER send a write command without human confirmation.
+- Before every write: show the human the exact plan (chat titles -> target
+  folders), run the intent with --dry-run, present the result, wait for an
+  explicit OK. No OK = no write.
+- Read commands (chats, contacts, read, folders, prime) change nothing. Use
+  them freely.
+
+## Commands
+
+  tg chats [--folder F] [--limit N]   all dialogs: id, title, type, unread,
+                                      folders, archived, last_message
+  tg read CHAT [--last N]             N most recent messages, oldest first
+  tg contacts                         contact list
+  tg folders                          folders with member chat ids
+  tg create-folder TITLE [--chat C]   new folder (TITLE <= 12 chars, max 10)
+  tg move CHAT --to F [--create]      add CHAT to folder F, ADDITIVE
+                                      [--dry-run: plan only, sends nothing]
+  tg archive CHAT [--undo]            archive / unarchive a chat
+
+Rules:
+- CHAT is a marked id from `tg chats` (users >0, groups <0, channels -100...)
+  or @username. Pass ids back verbatim.
+- F matches a folder by title (case-insensitive) or id. --create makes a
+  missing folder; folder names max 12 chars.
+- move is additive: a chat may live in several folders. "already" = no-op.
+- Throttle: sleep between writes, honor FloodWait.
+
+## Sort workflow
+
+1. Inventory:  tg chats
+2. Classify:   pick chats with empty or wrong folders, inspect content:
+               tg read <chat_id> --last 20
+3. Plan:       check existing folders (tg folders), assign each chat a folder
+4. CONFIRM:    show the human the plan + dry-run each move:
+               tg move <chat_id> --to "<folder>" --dry-run
+5. Apply only after explicit human approval:
+               tg move <chat_id> --to "<folder>"
+6. Optionally archive noise channels (same confirm rule):
+               tg archive <chat_id>
+
+## Example session
+
+$ tg chats
+[
+ { "id": -1001701234567, "title": "Solana News", "type": "channel",
+   "unread": 42, "folders": [], "archived": false,
+   "last_message": { "date": "...", "text": "Mainnet upgrade shipped" } }
+]
+
+$ tg read -1001701234567 --last 3
+[
+ { "id": 4812, "date": "...", "sender_id": 987654321,
+   "text": "SOL validators: upgrade at epoch 520" }
+]
+
+# -> propose to human: "Solana News" -> folder "Crypto" ; wait for OK
+
+$ tg move -1001701234567 --to Crypto --dry-run
+{
+ "chat": -1001701234567,
+ "folder": { "id": 5, "title": "Crypto" },
+ "action": "added",
+ "dry_run": true,
+ "include_count": { "before": 3, "after": 4 }
+}
+
+# human confirms -> apply
+$ tg move -1001701234567 --to Crypto
+"""
+
+
+class CliError(Exception):
+    pass
+
+
+def out(obj):
+    print(json.dumps(obj, default=str, ensure_ascii=False, indent=1))
+
+
+async def call(client, request):
+    try:
+        return await client(request)
+    except FloodWaitError as e:
+        await asyncio.sleep(e.seconds + 1)
+        return await client(request)
+
+
+def unwrap_filters(result):
+    fs = getattr(result, "filters", None)
+    return list(fs) if fs is not None else list(result or [])
+
+
+def custom_filters(filters):
+    return [f for f in filters if isinstance(f, types.DialogFilter)]
+
+
+def filter_title(f):
+    t = getattr(f, "title", "")
+    return getattr(t, "text", t)
+
+
+def find_filter(filters, name_or_id):
+    s = str(name_or_id).strip()
+    for f in custom_filters(filters):
+        if str(f.id) == s or filter_title(f).lower() == s.lower():
+            return f
+    return None
+
+
+def next_filter_id(filters):
+    ids = [f.id for f in custom_filters(filters)]
+    return max(ids, default=1) + 1
+
+
+def new_filter(fid, title):
+    if len(title) > MAX_TITLE:
+        raise CliError(f"folder title >{MAX_TITLE} chars: {title!r}")
+    return types.DialogFilter(
+        id=fid,
+        title=types.TextPlain(title),
+        pinned_peers=[],
+        include_peers=[],
+        exclude_peers=[],
+    )
+
+
+def folder_membership(filters):
+    mem = {}
+    for f in custom_filters(filters):
+        for p in f.include_peers or []:
+            mem.setdefault(utils.get_peer_id(p), []).append(filter_title(f))
+    return mem
+
+
+def chat_row(d, mem):
+    m = d.message
+    return {
+        "id": d.id,
+        "title": d.name,
+        "type": "user" if d.is_user else "group" if d.is_group else "channel",
+        "unread": d.unread_count,
+        "folders": mem.get(d.id, []),
+        "archived": bool(getattr(d, "archived", False)),
+        "last_message": {
+            "date": m.date,
+            "text": (getattr(m, "raw_text", "") or "")[:80],
+        }
+        if m
+        else None,
+    }
+
+
+def parse_chat(x):
+    x = str(x)
+    return int(x) if x.lstrip("-").isdigit() else x
+
+
+def make_client():
+    if not API_ID or not API_HASH:
+        raise CliError("set TG_API_ID and TG_API_HASH (from my.telegram.org)")
+    os.makedirs(os.path.dirname(SESSION), exist_ok=True)
+    return TelegramClient(SESSION, API_ID, API_HASH)
+
+
+async def must_auth(c):
+    if not await c.is_user_authorized():
+        raise CliError("not logged in - run: ./tg auth")
+
+
+@contextlib.asynccontextmanager
+async def session():
+    """Connect without start() - no interactive prompt hang for agents."""
+    c = make_client()
+    await c.connect()
+    try:
+        await must_auth(c)
+        yield c
+    finally:
+        await c.disconnect()
+
+
+async def fetch_filters(c):
+    return unwrap_filters(await call(c, functions.messages.GetDialogFiltersRequest()))
+
+
+async def move_chat(c, chat_id, target, create=False, dry=False):
+    ent = await c.get_entity(parse_chat(chat_id))
+    ip = utils.get_input_peer(ent)
+    marked = utils.get_peer_id(ip)
+    filters = await fetch_filters(c)
+    f = find_filter(filters, target)
+    created = False
+    if f is None:
+        if not create:
+            raise CliError(f"no folder {target!r} - use --create")
+        if len(custom_filters(filters)) >= MAX_FOLDERS:
+            raise CliError(f"folder limit reached ({MAX_FOLDERS})")
+        f = new_filter(next_filter_id(filters), str(target))
+        created = True
+    if marked in {utils.get_peer_id(p) for p in f.include_peers or []}:
+        return {"chat": marked, "folder": filter_title(f), "action": "already"}
+    before = len(f.include_peers or [])
+    f.include_peers = list(f.include_peers or []) + [ip]
+    if not dry:
+        await call(c, functions.messages.UpdateDialogFilterRequest(id=f.id, filter=f))
+    return {
+        "chat": marked,
+        "folder": {"id": f.id, "title": filter_title(f)},
+        "action": ("created+" if created else "") + "added",
+        "dry_run": dry,
+        "include_count": {"before": before, "after": len(f.include_peers)},
+    }
+
+
+# --- command handlers -------------------------------------------------------
+
+
+async def cmd_auth(_):
+    c = make_client()
+    await c.start()
+    me = await c.get_me()
+    out({"user": me.id, "name": (f"{me.first_name or ''} {me.last_name or ''}").strip()})
+    await c.disconnect()
+
+
+async def cmd_contacts(_):
+    async with session() as c:
+        await must_auth(c)
+        res = await call(c, functions.contacts.GetContactsRequest(hash=0))
+        out(
+            [
+                {
+                    "id": u.id,
+                    "name": " ".join(filter(None, [u.first_name, u.last_name])),
+                    "username": u.username,
+                    "phone": u.phone,
+                }
+                for u in getattr(res, "users", [])
+            ]
+        )
+
+
+async def cmd_chats(args):
+    async with session() as c:
+        await must_auth(c)
+        mem = folder_membership(await fetch_filters(c))
+        rows = []
+        async for d in c.iter_dialogs(limit=args.limit):
+            rows.append(chat_row(d, mem))
+        if args.folder:
+            rows = [r for r in rows if args.folder in r["folders"]]
+        out(rows)
+
+
+async def cmd_read(args):
+    async with session() as c:
+        await must_auth(c)
+        msgs = await c.get_messages(parse_chat(args.chat), limit=args.last)
+        out(
+            [
+                {
+                    "id": m.id,
+                    "date": m.date,
+                    "sender_id": m.sender_id,
+                    "text": (m.raw_text or "")[:200],
+                }
+                for m in reversed(msgs)
+            ]
+        )
+
+
+async def cmd_folders(_):
+    async with session() as c:
+        await must_auth(c)
+        out(
+            [
+                {
+                    "id": f.id,
+                    "title": filter_title(f),
+                    "emoticon": f.emoticon,
+                    "chats": [utils.get_peer_id(p) for p in f.include_peers or []],
+                }
+                for f in custom_filters(await fetch_filters(c))
+            ]
+        )
+
+
+async def cmd_create_folder(args):
+    async with session() as c:
+        await must_auth(c)
+        filters = await fetch_filters(c)
+        if len(custom_filters(filters)) >= MAX_FOLDERS:
+            raise CliError(f"folder limit reached ({MAX_FOLDERS})")
+        f = new_filter(next_filter_id(filters), args.title)
+        if args.chat:
+            ip = utils.get_input_peer(
+                await c.get_entity(parse_chat(args.chat))
+            )
+            f.include_peers = [ip]
+        await call(c, functions.messages.UpdateDialogFilterRequest(id=f.id, filter=f))
+        out({"created": {"id": f.id, "title": filter_title(f)}})
+
+
+async def cmd_move(args):
+    async with session() as c:
+        await must_auth(c)
+        out(
+            await move_chat(
+                c, args.chat, args.to, create=args.create, dry=args.dry_run
+            )
+        )
+
+
+async def cmd_prime(_):
+    print(PRIME)
+
+
+async def cmd_archive(args):
+    async with session() as c:
+        await must_auth(c)
+        ip = utils.get_input_peer(await c.get_entity(parse_chat(args.chat)))
+        fid = 0 if args.undo else ARCHIVE_ID
+        await call(
+            c,
+            functions.folders.EditPeerFoldersRequest(
+                folder_peers=[types.InputFolderPeer(peer=ip, folder_id=fid)]
+            ),
+        )
+        out({"chat": utils.get_peer_id(ip), "folder_id": fid})
+
+
+# --- CLI --------------------------------------------------------------------
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="tg", description=__doc__)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("auth", help="one-time interactive login")
+
+    sub.add_parser("prime", help="print the agent skill (how to use this CLI)")
+
+    sub.add_parser("contacts", help="list contacts")
+
+    sp = sub.add_parser("chats", help="list dialogs + folder memberships")
+    sp.add_argument("--folder", help="only chats in this folder (title)")
+    sp.add_argument("--limit", type=int, default=None)
+
+    sp = sub.add_parser("read", help="recent messages of a chat")
+    sp.add_argument("chat", help="chat id or @username")
+    sp.add_argument("--last", type=int, default=20)
+
+    sub.add_parser("folders", help="list folders")
+
+    sp = sub.add_parser("create-folder", help="create a folder")
+    sp.add_argument("title", help=f"<={MAX_TITLE} chars")
+    sp.add_argument("--chat", help="seed member (id or @username)")
+
+    sp = sub.add_parser("move", help="add chat to folder (additive)")
+    sp.add_argument("chat")
+    sp.add_argument("--to", required=True, help="folder title or id")
+    sp.add_argument("--create", action="store_true", help="create folder if missing")
+    sp.add_argument("--dry-run", action="store_true")
+
+    sp = sub.add_parser("archive", help="archive a chat")
+    sp.add_argument("chat")
+    sp.add_argument("--undo", action="store_true", help="unarchive")
+
+    args = p.parse_args(argv)
+    handler = {
+        "auth": cmd_auth,
+        "prime": cmd_prime,
+        "contacts": cmd_contacts,
+        "chats": cmd_chats,
+        "read": cmd_read,
+        "folders": cmd_folders,
+        "create-folder": cmd_create_folder,
+        "move": cmd_move,
+        "archive": cmd_archive,
+    }[args.cmd]
+    try:
+        asyncio.run(handler(args))
+    except CliError as e:
+        print(json.dumps({"error": str(e)}), file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tg2llm-0.1.0/uv.lock

@@ -0,0 +1,123 @@
+version = 1
+revision = 1
+requires-python = ">=3.12"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484 },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956 },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 },
+]
+
+[[package]]
+name = "pyaes"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/66/2c17bae31c906613795711fc78045c285048168919ace2220daa372c7d72/pyaes-1.6.1.tar.gz", hash = "sha256:02c1b1405c38d3c370b085fb952dd8bea3fadcee6411ad99f312cc129c536d8f", size = 28536 }
+
+[[package]]
+name = "pyasn1"
+version = "0.6.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/9a/23310166d960def5897e91fe20e5b724601b02a22e84ba1f94232c0b7f67/pyasn1-0.6.4.tar.gz", hash = "sha256:9c447d8431c947fe4c8febc4ed9e760bc29011a5b01e5c74b67025bd9fb8ce81", size = 151262 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3b/6163796d69c3977d1e4287bea4a6979161cbbdd170ebb430511e8e1999ce/pyasn1-0.6.4-py3-none-any.whl", hash = "sha256:deda9277cfd454080ec40b207fb6df82206a3a2688735233cdcd8d3d565f088b", size = 84410 },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147 },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536 },
+]
+
+[[package]]
+name = "rsa"
+version = "4.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyasn1" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696 },
+]
+
+[[package]]
+name = "telethon"
+version = "1.45.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyaes" },
+    { name = "rsa" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d5/07/b23b6cc73cd994763fbd641d196904f56cc966035eda841275b5689c6e5f/telethon-1.45.0.tar.gz", hash = "sha256:4cb7ae269b8ab9dad9fc490b859f0bc2f885121e990f5b20407b1faa0db2a1d9", size = 728057 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/ac/241c09e6905215f225d8088438ceb1f32cc4b4865f3f49068cb402debfd7/telethon-1.45.0-py3-none-any.whl", hash = "sha256:339e24c83aedc9f12cbe389264627edc49779e4289c535aa90aafc4ce62f7972", size = 804098 },
+]
+
+[[package]]
+name = "tg2llm"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "telethon" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "telethon", specifier = ">=1.45.0" }]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.1.1" }]