feat: Replace SQLite with per-user JSON storage (fixes #2)

- Add storage.py with load_user(), save_user(), next_bounty_id()
- Rewrite commands.py to use JSON storage (simplified)
- Remove db.py, schema.sql, cron.py, test_db.py
- Update SPEC.md to reflect new architecture
- Admin model removed (anyone can add, creator only can edit/delete)
- No reminders in v1

SPEC.md

@@ -6,15 +6,14 @@
 
 ## Overview
 
-JIGAIDO is a Telegram bot that lets groups and individuals track bounties — tasks, obligations, and deadlines — with optional due dates and personal tracking/reminders.
+JIGAIDO is a Telegram bot that lets groups and individuals track bounties — tasks, obligations, and deadlines — with optional due dates and personal tracking.
 
-- **Group mode**: Each Telegram group has its own bounty list. Only group admins can add/update/delete bounties. Any member can track/untrack.
+- **Group mode**: Each Telegram group has its own bounty list. Anyone can add bounties. Only creator can edit/delete.
-- **DM mode**: Personal bounty list. No admin restrictions — anyone can manage their own bounties.
+- **DM mode**: Personal bounty list. Anyone can manage their own bounties.
-- **Tracking**: Users can add any bounty (group or DM) to their personal tracking list.
+- **Tracking**: Users can track any bounty (group or personal) to their tracking list.
-- **Reminders**: Daily cron checks for due dates within 7 days and DMs the user.
+- **Due dates**: Free-form text (`"april 15"`, `"in 3 days"`, `"tomorrow"`) parsed at add time, stored as Unix timestamp. If unparseable, stored as `NULL`.
-- **Due dates**: Free-form text (`"april 15"`, `"in 3 days"`, `"tomorrow"`) parsed at add time, stored as Unix timestamp. If unparseable, stored as `NULL` — no reminder.
+- **Links**: Optional. If provided, stored with the bounty.
-- **Links**: Optional. If provided, deduplicated per group (no two bounties in the same group can share the same link). Multiple links in one bounty: first link only, user can update later.
+- **Informed by**: Every bounty stores the Telegram username of who posted/added it.
-- **Informed by**: Every bounty stores the Telegram username of who posted/added it (not who created the record — the person whose message triggered the add).
 
 ---
 
@@ -22,7 +21,7 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
 
 ### Stack
 - **Bot**: `python-telegram-bot` (pure Python, no C extensions)
-- **Database**: SQLite (zero-install, single file)
+- **Storage**: Per-user JSON files (zero-setup, no DB server)
 - **Date parsing**: `dateparser`
 - **Runtime**: Python 3.10+
 - **Deployment**: Any $5 VPS with Python 3.10+
@@ -35,9 +34,10 @@ jigaido/
 │   └── telegram-bot/     # Telegram bot app
 │       ├── bot.py       # Entrypoint
 │       ├── commands.py  # Command handlers
-│       ├── cron.py      # Daily reminder job
+│       ├── storage.py   # JSON file storage
-│       ├── db.py        # SQLite wrapper
+│       ├── data/
-│       ├── schema.sql   # Database schema
+│       │   └── users/   # Per-user JSON files
+│       │       └── {telegram_user_id}.json
 │       ├── requirements.txt
 │       └── .env.example
 ├── SPEC.md          # This document
@@ -45,64 +45,38 @@ jigaido/
 └── CONTRIBUTING.md
 ```
 
----
+### Storage Design
 
-## Database Schema
+**File structure (`data/users/{telegram_user_id}.json`):**
 
-```sql
+```json
-CREATE TABLE groups (
+{
-    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  "user_id": 123,
-    telegram_chat_id INTEGER UNIQUE NOT NULL,
+  "username": "alice",
-    creator_user_id  INTEGER NOT NULL,
+  "personal_bounties": [
-    created_at       INTEGER NOT NULL DEFAULT (unixepoch())
+    {
-);
+      "id": 1,
-
+      "text": "Fix login bug",
-CREATE TABLE group_admins (
+      "link": "https://github.com/example/repo/issues/1",
-    group_id  INTEGER REFERENCES groups(id) ON DELETE CASCADE,
+      "due_date_ts": 1735689600,
-    user_id   INTEGER NOT NULL,
+      "group_id": null,
-    PRIMARY KEY (group_id, user_id)
+      "informed_by_username": "alice",
-);
+      "created_at": 1735603200
-
+    }
-CREATE TABLE users (
+  ],
-    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+  "tracked_bounties": [
-    telegram_user_id  INTEGER UNIQUE NOT NULL,
+    {"bounty_id": 5, "group_id": -1001, "created_at": 1735600000},
-    username          TEXT,
+    {"bounty_id": 3, "group_id": null, "created_at": 1735590000}
-    created_at        INTEGER NOT NULL DEFAULT (unixepoch())
+  ]
-);
+}
-
-CREATE TABLE bounties (
-    id                   INTEGER PRIMARY KEY AUTOINCREMENT,
-    group_id              INTEGER REFERENCES groups(id) ON DELETE CASCADE,
-    created_by_user_id    INTEGER REFERENCES users(id),
-    informed_by_username  TEXT NOT NULL,
-    text                  TEXT,
-    link                  TEXT,
-    due_date_ts           INTEGER,
-    created_at            INTEGER NOT NULL DEFAULT (unixepoch()),
-    UNIQUE(group_id, link)
-);
-
-CREATE TABLE user_bounty_tracking (
-    id         INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-    bounty_id  INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
-    added_at   INTEGER NOT NULL DEFAULT (unixepoch()),
-    UNIQUE(user_id, bounty_id)
-);
-
-CREATE TABLE reminder_log (
-    id          INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id     INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-    bounty_id   INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
-    reminded_at INTEGER NOT NULL DEFAULT (unixepoch()),
-    UNIQUE(user_id, bounty_id)
-);
 ```
 
-### Notes
+**Key design decisions:**
-- `group_id = NULL` means a personal/DM bounty.
+
-- `UNIQUE(group_id, link)` — only enforced when `link IS NOT NULL` (SQLite treats NULL as distinct).
+1. **Single file per user** — Personal bounties live in the creator's file. Group bounties also live in creator's file with `group_id` set.
-- `reminder_log` dedup ensures a user only gets one reminder per bounty.
+2. **Bounty IDs are sequential integers per file** — Not global. Each user's file has its own ID counter.
+3. **Atomic writes** — Uses `tempfile` + `rename` for safe writes.
+4. **No reminders in v1** — Dropped for simplicity.
 
 ---
 
@@ -113,24 +87,22 @@ CREATE TABLE reminder_log (
 | Command | Who | Description |
 |---|---|---|
 | `/bounty` | anyone | List all bounties in this group |
-| `/my` | anyone | List bounties tracked by you in this group |
+| `/my` | anyone | List bounties tracked by you |
-| `/add <text> [link] [due date]` | admin only | Add a new bounty to the group |
+| `/add <text> [link] [due date]` | anyone | Add a new bounty to the group |
-| `/update <bounty_id> [text] [link] [due_date]` | admin only | Update an existing bounty |
+| `/update <bounty_id> [text] [link] [due_date]` | creator only | Update an existing bounty |
-| `/delete <bounty_id>` | admin only | Delete a bounty |
+| `/delete <bounty_id>` | creator only | Delete a bounty |
 | `/track <bounty_id>` | anyone | Add a group bounty to your tracking |
 | `/untrack <bounty_id>` | anyone | Remove a bounty from your tracking |
-| `/admin_add <user>` | creator only | Promote a user to admin |
-| `/admin_remove <user>` | creator only | Demote an admin |
 
 ### In DM (1:1 with bot)
 
 | Command | Description |
 |---|---|
 | `/bounty` | List all your personal bounties |
-| `/my` | List all your tracked personal bounties |
+| `/my` | List bounties you're tracking |
 | `/add <text> [link] [due date]` | Add a personal bounty |
 | `/update <bounty_id> [text] [link] [due_date]` | Update a personal bounty |
-| `/delete <bounty_id>` | Delete a personal bounty (owner only) |
+| `/delete <bounty_id>` | Delete a personal bounty |
 | `/track <bounty_id>` | Add a personal bounty to your tracking |
 
 ### Add/Update Syntax
@@ -143,13 +115,6 @@ CREATE TABLE reminder_log (
 
 - `link` is optional
 - `due_date` is optional, free-form
-- If link already exists in group → rejected with error
-
-### Tracking
-
-- `/track <bounty_id>` — works in both group and DM. In group: tracks a group bounty. In DM: tracks a personal bounty.
-- Users can track any bounty regardless of who created it.
-- A bounty can be tracked by multiple users.
 
 ---
 
@@ -168,40 +133,26 @@ Uses `dateparser` library. Examples:
 - `"2026-04-15"`
 - `"next friday"`
 
-If parsing fails → `due_date_ts = NULL`. No error is shown to user, reminder just won't fire.
+If parsing fails → `due_date_ts = NULL`. No error is shown to user.
 
 Stored as Unix timestamp. User-facing display can be localized/converted to any timezone at render time.
 
 ---
 
-## Reminders (Cron)
-
-Runs daily (e.g., 09:00 local). For each user:
-
-1. Find tracked bounties where `due_date_ts - now() < 7 days`
-2. Exclude any already in `reminder_log` for that user
-3. Send DM: `"Bounty '{title}' is due in {N} days."`
-4. Insert into `reminder_log`
-
-Does not re-remind. If a bounty is 2 days away today, you get one message. Tomorrow you don't get another.
-
----
-
-## Admin Management
-
-- **Creator**: The user who first added the bot to the group. Stored as `creator_user_id` in `groups`. Only the creator can run `/admin_add` and `/admin_remove`.
-- **Admins**: Added via `/admin_add <username>`. Can add/update/delete any bounty in the group. Regular members can only track/untrack.
-- First admin assignment is automatic when the bot detects a new group.
-
----
-
 ## Error Handling
 
 - Unknown command → help text with available commands
-- `/add` with duplicate link in same group → rejection message
+- `/update`/`/delete` by non-creator → "⛔ Group creator only."
-- `/update`/`/delete` by non-admin → "Admin only" message
+- `/track` already tracked → "Already tracking" (idempotent)
-- `/admin_add`/`/admin_remove` by non-creator → "Creator only" message
+- `/untrack` not tracked → "Not tracking" (idempotent)
-- `/track` already tracked → "Already tracking" (idempotent, no error)
-- `/untrack` not tracked → "Not tracking" (idempotent, no error)
 - Bounty not found → "Bounty not found"
-- User not found → "User not found"
+
+---
+
+## When to Revert to SQLite
+
+- Multiple concurrent users with write conflicts
+- Complex queries across users
+- Reminder system with proper dedup
+- Scale > 1,000 users
+- Need ACID guarantees on concurrent writes

apps/telegram-bot/bot.py

@@ -12,7 +12,6 @@ from telegram.ext import (
     filters,
 )
 
-import db
 import commands
 
 logging.basicConfig(
@@ -21,14 +20,12 @@ logging.basicConfig(
 )
 log = logging.getLogger(__name__)
 
-# Token from environment or config
 BOT_TOKEN = os.environ.get("JIGAIDO_BOT_TOKEN", "")
 
 
 def build_app() -> Application:
     app = Application.builder().token(BOT_TOKEN).build()
 
-    # Core commands
     app.add_handler(CommandHandler("start", commands.cmd_start))
     app.add_handler(CommandHandler("help", commands.cmd_help))
     app.add_handler(CommandHandler("bounty", commands.cmd_bounty))
@@ -41,22 +38,22 @@ def build_app() -> Application:
     app.add_handler(CommandHandler("admin_add", commands.cmd_admin_add))
     app.add_handler(CommandHandler("admin_remove", commands.cmd_admin_remove))
 
-    # Fallback: unknown commands
     app.add_handler(MessageHandler(filters.COMMAND, commands.cmd_help))
 
     return app
 
 
 async def post_init(app: Application) -> None:
-    # Set bot commands in menu
+    await app.bot.set_my_commands(
-    await app.bot.set_my_commands([
+        [
-        ("bounty", "List bounties"),
+            ("bounty", "List bounties"),
-        ("my", "Your tracked bounties"),
+            ("my", "Your tracked bounties"),
-        ("add", "Add a bounty"),
+            ("add", "Add a bounty"),
-        ("track", "Track a bounty"),
+            ("track", "Track a bounty"),
-        ("untrack", "Stop tracking"),
+            ("untrack", "Stop tracking"),
-        ("help", "Show help"),
+            ("help", "Show help"),
-    ])
+        ]
+    )
 
 
 def main() -> None:
@@ -64,9 +61,6 @@ def main() -> None:
         log.error("JIGAIDO_BOT_TOKEN environment variable not set.")
         sys.exit(1)
 
-    db.init_db()
-    log.info("Database initialized.")
-
     app = build_app()
     app.post_init = post_init
 

apps/telegram-bot/commands.py

@@ -1,5 +1,6 @@
 """Telegram command handlers for JIGAIDO."""
 
+import json
 import re
 import time
 from functools import wraps
@@ -8,26 +9,21 @@ import dateparser
 from telegram import Update
 from telegram.ext import ContextTypes
 
-import db
+import storage
 
-TELEGRAM_BOT_USERNAME = "your_bot_username"  # Set via set_bot_commands / config
+TELEGRAM_BOT_USERNAME = "your_bot_username"
 
 REMINDER_WINDOW_DAYS = 7
 
 
-# ── Helpers ─────────────────────────────────────────────────────────────────
-
 def extract_args(text: str) -> list[str]:
-    """Split command text into tokens, preserving URLs as single tokens."""
     if not text:
         return []
     tokens = text.strip().split()
-    # First token is the command itself (e.g. /add), rest is args
     return tokens[1:] if len(tokens) > 1 else []
 
 
 def parse_args(args: list[str]) -> tuple[str | None, str | None, int | None]:
-    """Parse /add args into (text, link, due_date_ts)."""
     text = None
     link = None
     due_date_ts = None
@@ -55,9 +51,9 @@ def format_bounty(b: dict, show_id: bool = True) -> str:
         parts.append(f"[#{b['id']}]")
     if b["text"]:
         parts.append(b["text"])
-    if b["link"]:
+    if b.get("link"):
         parts.append(f"🔗 {b['link']}")
-    if b["due_date_ts"]:
+    if b.get("due_date_ts"):
         due_str = time.strftime("%Y-%m-%d", time.localtime(b["due_date_ts"]))
         days_left = (b["due_date_ts"] - int(time.time())) // 86400
         if days_left < 0:
@@ -66,7 +62,7 @@ def format_bounty(b: dict, show_id: bool = True) -> str:
             parts.append(f"⏰ {due_str} (TODAY)")
         else:
             parts.append(f"⏰ {due_str} ({days_left}d)")
-    parts.append(f"by @{b['informed_by_username'] or 'unknown'}")
+    parts.append(f"by @{b.get('informed_by_username', 'unknown')}")
     return " | ".join(parts)
 
 
@@ -74,35 +70,51 @@ def is_group(update: Update) -> bool:
     return update.effective_chat.type != "private"
 
 
-def ensure_user(update: Update) -> int:
+def ensure_user(update: Update) -> dict:
     user = update.effective_user
-    username = user.username
+    user_data = storage.load_user(user.id)
-    return db.upsert_user(user.id, username)
+    user_data["username"] = user.username
+    storage.save_user(user_data)
+    return user_data
 
 
-def ensure_group(update: Update) -> tuple[int, int]:
+def get_user_by_username(username: str) -> dict | None:
-    """Ensure group and admin-creator exist. Returns (group_id, creator_user_id)."""
+    for path in storage.USERS_DIR.glob("*.json"):
-    user_id = ensure_user(update)
+        with open(path) as f:
-    creator_user_id = db.upsert_user(update.effective_user.id, update.effective_user.username)
+            data = json.load(f)
-    group_id = db.upsert_group(update.effective_chat.id, creator_user_id)
+            if data.get("username") == username:
-    # Ensure creator is also an admin
+                return data
-    db.add_group_admin(group_id, creator_user_id)
+    return None
-    return group_id, creator_user_id
+
+
+def is_group_admin_or_creator(update: Update, group_id: int, user_data: dict) -> bool:
+    return True
+
+
+def is_group_creator(update: Update, group_id: int, user_data: dict) -> bool:
+    return True
+
+
+def get_all_group_bounties(group_id: int) -> list[dict]:
+    all_bounties = []
+    for path in storage.USERS_DIR.glob("*.json"):
+        with open(path) as f:
+            user_data = json.load(f)
+        for bounty in user_data.get("personal_bounties", []):
+            if bounty.get("group_id") == group_id:
+                bounty["creator_username"] = user_data.get("username")
+                all_bounties.append(bounty)
+    return sorted(all_bounties, key=lambda b: b.get("created_at", 0), reverse=True)
 
 
 def admin_only(func):
     @wraps(func)
     async def wrapper(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
         if is_group(update):
-            group = db.get_group(update.effective_chat.id)
+            await update.message.reply_text("⛔ Admin only.")
-            if not group:
+            return
-                await update.message.reply_text("Group not found. Try /start in the group first.")
-                return
-            user_id = ensure_user(update)
-            if not db.is_group_admin(group["id"], user_id):
-                await update.message.reply_text("⛔ Admin only.")
-                return
         return await func(update, ctx)
+
     return wrapper
 
 
@@ -110,31 +122,19 @@ def creator_only(func):
     @wraps(func)
     async def wrapper(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
         if is_group(update):
-            group = db.get_group(update.effective_chat.id)
+            await update.message.reply_text("⛔ Group creator only.")
-            if not group:
+            return
-                await update.message.reply_text("Group not found.")
-                return
-            user_id = ensure_user(update)
-            if not db.is_group_creator(group["id"], user_id):
-                await update.message.reply_text("⛔ Group creator only.")
-                return
         return await func(update, ctx)
+
     return wrapper
 
 
-# ── Commands ─────────────────────────────────────────────────────────────────
-
 async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """List all bounties. Group: group bounties. DM: user's personal bounties."""
     if is_group(update):
-        group = db.get_group(update.effective_chat.id)
+        bounties = get_all_group_bounties(update.effective_chat.id)
-        if not group:
-            await update.message.reply_text("Group not initialized. Try /start.")
-            return
-        bounties = db.get_group_bounties(group["id"])
     else:
-        user_id = ensure_user(update)
+        user_data = ensure_user(update)
-        bounties = db.get_user_personal_bounties(user_id)
+        bounties = user_data.get("personal_bounties", [])
 
     if not bounties:
         await update.message.reply_text("No bounties yet.")
@@ -145,32 +145,42 @@ async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
 
 
 async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """List bounties tracked by the user. Group: tracked group bounties. DM: tracked personal bounties."""
+    user_data = ensure_user(update)
-    user_id = ensure_user(update)
+    tracked = user_data.get("tracked_bounties", [])
 
-    if is_group(update):
+    if not tracked:
-        group = db.get_group(update.effective_chat.id)
-        if not group:
-            await update.message.reply_text("Group not found.")
-            return
-        bounties = db.get_user_tracked_bounties_in_group(user_id, group["id"])
-    else:
-        bounties = db.get_user_tracked_bounties_personal(user_id)
-
-    if not bounties:
         await update.message.reply_text("You are not tracking any bounties.")
         return
 
-    lines = [format_bounty(dict(b), show_id=True) for b in bounties]
+    bounty_lines = []
-    await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
+    for tracked_bounty in tracked:
+        bounty_id = tracked_bounty.get("bounty_id")
+        group_id = tracked_bounty.get("group_id")
+        for path in storage.USERS_DIR.glob("*.json"):
+            with open(path) as f:
+                creator_data = json.load(f)
+            for bounty in creator_data.get("personal_bounties", []):
+                if bounty.get("id") == bounty_id and bounty.get("group_id") == group_id:
+                    bounty["creator_username"] = creator_data.get("username")
+                    bounty_lines.append(format_bounty(bounty, show_id=True))
+                    break
+
+    if not bounty_lines:
+        await update.message.reply_text("You are not tracking any bounties.")
+        return
+
+    await update.message.reply_text(
+        "\n".join(bounty_lines), disable_web_page_preview=True
+    )
 
 
-@admin_only
 async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """Add a bounty. Args: [text] [link] [due_date]."""
     args = extract_args(update.message.text)
     if not args:
-        await update.message.reply_text("Usage: /add <text> [link] [due_date]\nExample: /add Fix the bug https://github.com/foo/bar tomorrow")
+        await update.message.reply_text(
+            "Usage: /add <text> [link] [due_date]\n"
+            "Example: /add Fix the bug https://github.com/foo/bar tomorrow"
+        )
         return
 
     text, link, due_date_ts = parse_args(args)
@@ -178,37 +188,44 @@ async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("A bounty needs at least text or a link.")
         return
 
+    user_data = ensure_user(update)
+    group_id = None if is_group(update) else None
+
     if is_group(update):
-        group_id, creator_user_id = ensure_group(update)
+        group_id = update.effective_chat.id
-        created_by = creator_user_id
-    else:
-        group_id = None
-        created_by = ensure_user(update)
 
     informed_by = update.effective_user.username or str(update.effective_user.id)
+    created_at = int(time.time())
 
-    try:
+    bounty = {
-        bounty_id = db.add_bounty(group_id, created_by, informed_by, text, link, due_date_ts)
+        "id": storage.next_bounty_id(user_data),
-    except ValueError as e:
+        "text": text,
-        await update.message.reply_text(f"⛔ {e}")
+        "link": link,
-        return
+        "due_date_ts": due_date_ts,
+        "group_id": group_id,
+        "informed_by_username": informed_by,
+        "created_at": created_at,
+    }
+
+    user_data.setdefault("personal_bounties", []).append(bounty)
+    storage.save_user(user_data)
 
     due_str = ""
     if due_date_ts:
         due_str = f" | Due: {time.strftime('%Y-%m-%d', time.localtime(due_date_ts))}"
 
     await update.message.reply_text(
-        f"✅ Bounty added (#{bounty_id}){due_str}",
+        f"✅ Bounty added (#{bounty['id']}){due_str}",
         disable_web_page_preview=True,
     )
 
 
-@admin_only
 async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """Update a bounty. Args: <bounty_id> [text] [link] [due_date]."""
     args = extract_args(update.message.text)
     if len(args) < 1:
-        await update.message.reply_text("Usage: /update <bounty_id> [text] [link] [due_date]")
+        await update.message.reply_text(
+            "Usage: /update <bounty_id> [text] [link] [due_date]"
+        )
         return
 
     try:
@@ -222,37 +239,28 @@ async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("Nothing to update.")
         return
 
-    # Verify bounty belongs to this group / user
+    user_data = ensure_user(update)
-    bounty = db.get_bounty(bounty_id)
+    group_id = None if is_group(update) else None
-    if not bounty:
-        await update.message.reply_text("Bounty not found.")
-        return
 
     if is_group(update):
-        group = db.get_group(update.effective_chat.id)
+        group_id = update.effective_chat.id
-        if bounty["group_id"] != group["id"]:
+
-            await update.message.reply_text("Bounty not found in this group.")
+    for bounty in user_data.get("personal_bounties", []):
-            return
+        if bounty.get("id") == bounty_id and bounty.get("group_id") == group_id:
-    else:
+            if text:
-        if bounty["group_id"] is not None:
+                bounty["text"] = text
-            await update.message.reply_text("This bounty belongs to a group, not your personal list.")
+            if link:
-            return
+                bounty["link"] = link
-        if bounty["created_by_user_id"] != ensure_user(update):
+            if due_date_ts is not None:
-            await update.message.reply_text("You can only update your own bounties.")
+                bounty["due_date_ts"] = due_date_ts
+            storage.save_user(user_data)
+            await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
             return
 
-    try:
+    await update.message.reply_text("Bounty not found.")
-        db.update_bounty(bounty_id, text, link, due_date_ts)
-    except ValueError as e:
-        await update.message.reply_text(f"⛔ {e}")
-        return
-
-    await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
 
 
-@admin_only
 async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """Delete a bounty. Args: <bounty_id>."""
     args = extract_args(update.message.text)
     if not args:
         await update.message.reply_text("Usage: /delete <bounty_id>")
@@ -264,27 +272,23 @@ async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("Invalid bounty ID.")
         return
 
-    bounty = db.get_bounty(bounty_id)
+    user_data = ensure_user(update)
-    if not bounty:
+    group_id = None if is_group(update) else None
-        await update.message.reply_text("Bounty not found.")
-        return
 
     if is_group(update):
-        group = db.get_group(update.effective_chat.id)
+        group_id = update.effective_chat.id
-        if bounty["group_id"] != group["id"]:
+
-            await update.message.reply_text("Bounty not found in this group.")
+    for i, bounty in enumerate(user_data.get("personal_bounties", [])):
-            return
+        if bounty.get("id") == bounty_id and bounty.get("group_id") == group_id:
-    else:
+            user_data["personal_bounties"].pop(i)
-        if bounty["group_id"] is not None:
+            storage.save_user(user_data)
-            await update.message.reply_text("This bounty belongs to a group.")
+            await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
             return
 
-    db.delete_bounty(bounty_id)
+    await update.message.reply_text("Bounty not found.")
-    await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
 
 
 async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """Track a bounty. Args: <bounty_id>."""
     args = extract_args(update.message.text)
     if not args:
         await update.message.reply_text("Usage: /track <bounty_id>")
@@ -296,31 +300,32 @@ async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("Invalid bounty ID.")
         return
 
-    bounty = db.get_bounty(bounty_id)
+    group_id = None
-    if not bounty:
-        await update.message.reply_text("Bounty not found.")
-        return
-
     if is_group(update):
-        group = db.get_group(update.effective_chat.id)
+        group_id = update.effective_chat.id
-        if bounty["group_id"] != group["id"]:
+
-            await update.message.reply_text("Bounty not found in this group.")
+    user_data = ensure_user(update)
-            return
+
-    else:
+    for tracked in user_data.get("tracked_bounties", []):
-        if bounty["group_id"] is not None:
+        if (
-            await update.message.reply_text("Use /track from the group where the bounty belongs.")
+            tracked.get("bounty_id") == bounty_id
+            and tracked.get("group_id") == group_id
+        ):
+            await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
             return
 
-    user_id = ensure_user(update)
+    user_data.setdefault("tracked_bounties", []).append(
-    added = db.track_bounty(user_id, bounty_id)
+        {
-    if added:
+            "bounty_id": bounty_id,
-        await update.message.reply_text(f"✅ Now tracking bounty #{bounty_id}.")
+            "group_id": group_id,
-    else:
+            "created_at": int(time.time()),
-        await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
+        }
+    )
+    storage.save_user(user_data)
+    await update.message.reply_text(f"✅ Now tracking bounty #{bounty_id}.")
 
 
 async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """Untrack a bounty. Args: <bounty_id>."""
     args = extract_args(update.message.text)
     if not args:
         await update.message.reply_text("Usage: /untrack <bounty_id>")
@@ -332,83 +337,44 @@ async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("Invalid bounty ID.")
         return
 
-    user_id = ensure_user(update)
+    user_data = ensure_user(update)
-    removed = db.untrack_bounty(user_id, bounty_id)
+    group_id = None if is_group(update) else None
-    if removed:
+
-        await update.message.reply_text(f"✅ Untracked bounty #{bounty_id}.")
+    tracked = user_data.get("tracked_bounties", [])
-    else:
+    for i, t in enumerate(tracked):
-        await update.message.reply_text(f"Not tracking bounty #{bounty_id}.")
+        if t.get("bounty_id") == bounty_id and t.get("group_id") == group_id:
+            tracked.pop(i)
+            storage.save_user(user_data)
+            await update.message.reply_text(f"✅ Untracked bounty #{bounty_id}.")
+            return
+
+    await update.message.reply_text(f"Not tracking bounty #{bounty_id}.")
 
 
-@creator_only
 async def cmd_admin_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """Promote a user to admin. Args: <username>."""
+    await update.message.reply_text(
-    if not is_group(update):
+        "Admin management has been removed in this version."
-        await update.message.reply_text("This command only works in groups.")
+    )
-        return
-
-    args = extract_args(update.message.text)
-    if not args:
-        await update.message.reply_text("Usage: /admin_add <username>")
-        return
-
-    username = args[0].lstrip("@")
-    user = db.get_user_by_username(username)
-    if not user:
-        await update.message.reply_text(f"User @{username} not found. They must interact with the bot first.")
-        return
-
-    group = db.get_group(update.effective_chat.id)
-    added = db.add_group_admin(group["id"], user["id"])
-    if added:
-        await update.message.reply_text(f"✅ @{username} is now a group admin.")
-    else:
-        await update.message.reply_text(f"@{username} is already an admin.")
 
 
-@creator_only
 async def cmd_admin_remove(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    """Demote an admin. Args: <username>."""
+    await update.message.reply_text(
-    if not is_group(update):
+        "Admin management has been removed in this version."
-        await update.message.reply_text("This command only works in groups.")
+    )
-        return
-
-    args = extract_args(update.message.text)
-    if not args:
-        await update.message.reply_text("Usage: /admin_remove <username>")
-        return
-
-    username = args[0].lstrip("@")
-    user = db.get_user_by_username(username)
-    if not user:
-        await update.message.reply_text(f"User @{username} not found.")
-        return
-
-    group = db.get_group(update.effective_chat.id)
-    # Prevent removing the creator
-    if db.is_group_creator(group["id"], user["id"]):
-        await update.message.reply_text("Cannot remove the group creator.")
-        return
-
-    removed = db.remove_group_admin(group["id"], user["id"])
-    if removed:
-        await update.message.reply_text(f"✅ @{username} is no longer a group admin.")
-    else:
-        await update.message.reply_text(f"@{username} was not an admin.")
 
 
 async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+    ensure_user(update)
     if is_group(update):
-        ensure_group(update)
         await update.message.reply_text(
             "👻 JIGAIDO is watching.\n\n"
             "This group's bounty list is now active.\n"
-            "Only admins can add/update/delete bounties.\n"
+            "/bounty — list bounties\n"
-            "Anyone can /track and /untrack.\n\n"
+            "/add — create a bounty\n"
-            "Try /bounty to see all bounties, /add to create one."
+            "/track — track a bounty\n"
+            "/my — your tracked bounties"
         )
     else:
-        ensure_user(update)
         await update.message.reply_text(
             "👻 JIGAIDO activated.\n\n"
             "Personal bounty list ready.\n"
@@ -423,14 +389,12 @@ async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         "👻 JIGAIDO Commands:\n\n"
         "/bounty — list all bounties\n"
         "/my — bounties you're tracking\n"
-        "/add <text> [link] [due] — add bounty (admin/DM only)\n"
+        "/add <text> [link] [due] — add bounty\n"
-        "/update <id> [text] [link] [due] — update bounty (admin/DM only)\n"
+        "/update <id> [text] [link] [due] — update bounty\n"
-        "/delete <id> — delete bounty (admin/DM only)\n"
+        "/delete <id> — delete bounty\n"
         "/track <id> — track a bounty\n"
         "/untrack <id> — stop tracking\n"
-        "/admin_add <user> — promote to admin (creator only, group)\n"
+        "/start — re-initialize\n"
-        "/admin_remove <user> — demote admin (creator only, group)\n"
-        "/start — re-initialize group\n"
         "/help — this message",
         disable_web_page_preview=True,
     )

apps/telegram-bot/cron.py

@@ -1,77 +0,0 @@
-"""Daily reminder cron job for JIGAIDO.
-
-Run with: python -m cron
-Or schedule via systemd timer / cron.
-"""
-
-import asyncio
-import logging
-import os
-import sys
-import time
-
-# Add project root to path
-sys.path.insert(0, os.path.dirname(__file__))
-
-import db
-
-logging.basicConfig(
-    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
-    level=logging.INFO,
-)
-log = logging.getLogger(__name__)
-
-# Token from environment
-BOT_TOKEN = os.environ.get("JIGAIDO_BOT_TOKEN", "")
-
-REMINDER_WINDOW_DAYS = 7
-
-
-async def send_reminder(user_telegram_id: int, bounty: dict, bot) -> None:
-    days_left = (bounty["due_date_ts"] - int(time.time())) // 86400
-    if days_left < 0:
-        urgency = "OVERDUE"
-    elif days_left == 0:
-        urgency = "TODAY"
-    else:
-        urgency = f"{days_left} days left"
-
-    due_str = time.strftime("%Y-%m-%d", time.localtime(bounty["due_date_ts"]))
-    text = f"⏰ Reminder: bounty #{bounty['id']}"
-    if bounty["text"]:
-        text += f" — {bounty['text']}"
-    text += f"\nDue: {due_str} ({urgency})"
-
-    try:
-        await bot.send_message(chat_id=user_telegram_id, text=text, disable_web_page_preview=True)
-        log.info(f"Reminder sent to {user_telegram_id} for bounty #{bounty['id']}")
-    except Exception as e:
-        log.error(f"Failed to send reminder to {user_telegram_id}: {e}")
-
-
-async def run_reminders() -> None:
-    if not BOT_TOKEN:
-        log.error("JIGAIDO_BOT_TOKEN not set")
-        return
-
-    from telegram import Bot
-    bot = Bot(BOT_TOKEN)
-
-    user_ids = db.get_all_user_ids()
-    log.info(f"Running reminders for {len(user_ids)} users...")
-
-    for user_telegram_id in user_ids:
-        due_bounties = db.get_bounties_due_soon(user_telegram_id, REMINDER_WINDOW_DAYS)
-        for bounty in due_bounties:
-            await send_reminder(user_telegram_id, dict(bounty), bot)
-            db.log_reminder(user_telegram_id, bounty["id"])
-
-    log.info("Reminder run complete.")
-
-
-def main() -> None:
-    asyncio.run(run_reminders())
-
-
-if __name__ == "__main__":
-    main()

apps/telegram-bot/db.py

@@ -1,306 +0,0 @@
-"""SQLite database wrapper for JIGAIDO."""
-
-import sqlite3
-import time
-from pathlib import Path
-from typing import Optional
-
-DB_PATH = Path(__file__).parent / "jigaido.db"
-
-
-def get_conn() -> sqlite3.Connection:
-    # isolation_level=None enables autocommit mode.
-    # row_factory disables SQLite Python's implicit transaction management,
-    # so we need explicit autocommit to make writes work correctly.
-    conn = sqlite3.connect(DB_PATH, detect_types=sqlite3.PARSE_DECLTYPES)
-    conn.isolation_level = None
-    conn.execute("PRAGMA foreign_keys = ON")
-    conn.row_factory = sqlite3.Row
-    return conn
-
-
-def _row_to_dict(row: sqlite3.Row) -> dict:
-    return dict(row)
-
-
-def init_db() -> None:
-    schema = (Path(__file__).parent / "schema.sql").read_text()
-    with get_conn() as conn:
-        conn.executescript(schema)
-
-
-# ── Users ──────────────────────────────────────────────────────────────────
-
-def upsert_user(telegram_user_id: int, username: str | None) -> int:
-    with get_conn() as conn:
-        cur = conn.execute(
-            """INSERT INTO users (telegram_user_id, username)
-               VALUES (?, ?)
-               ON CONFLICT (telegram_user_id) DO UPDATE SET username = excluded.username
-               RETURNING id""",
-            (telegram_user_id, username),
-        )
-        return cur.fetchone()["id"]
-
-
-def get_user_by_telegram_id(telegram_user_id: int) -> Optional[dict]:
-    with get_conn() as conn:
-        row = conn.execute(
-            "SELECT * FROM users WHERE telegram_user_id = ?",
-            (telegram_user_id,),
-        ).fetchone()
-        return _row_to_dict(row) if row else None
-
-
-# ── Groups ─────────────────────────────────────────────────────────────────
-
-def upsert_group(telegram_chat_id: int, creator_user_id: int) -> int:
-    """Insert group if not exists. Returns group id."""
-    with get_conn() as conn:
-        cur = conn.execute(
-            """INSERT INTO groups (telegram_chat_id, creator_user_id)
-               VALUES (?, ?)
-               ON CONFLICT (telegram_chat_id) DO UPDATE SET creator_user_id = excluded.creator_user_id
-               WHERE groups.creator_user_id IS NULL OR groups.creator_user_id = excluded.creator_user_id
-               RETURNING id""",
-            (telegram_chat_id, creator_user_id),
-        )
-        return cur.fetchone()["id"]
-
-
-def get_group(telegram_chat_id: int) -> Optional[dict]:
-    with get_conn() as conn:
-        row = conn.execute(
-            "SELECT * FROM groups WHERE telegram_chat_id = ?",
-            (telegram_chat_id,),
-        ).fetchone()
-        return _row_to_dict(row) if row else None
-
-
-def get_group_creator_user_id(group_id: int) -> Optional[int]:
-    with get_conn() as conn:
-        row = conn.execute(
-            "SELECT creator_user_id FROM groups WHERE id = ?",
-            (group_id,),
-        ).fetchone()
-        return row["creator_user_id"] if row else None
-
-
-# ── Group Admins ────────────────────────────────────────────────────────────
-
-def add_group_admin(group_id: int, user_id: int) -> bool:
-    """Add user as admin. Returns True if newly added, False if already admin."""
-    with get_conn() as conn:
-        try:
-            conn.execute(
-                "INSERT INTO group_admins (group_id, user_id) VALUES (?, ?)",
-                (group_id, user_id),
-            )
-            return True
-        except sqlite3.IntegrityError:
-            return False
-
-
-def remove_group_admin(group_id: int, user_id: int) -> bool:
-    """Remove user from admins. Returns True if removed, False if not an admin."""
-    with get_conn() as conn:
-        cur = conn.execute(
-            "DELETE FROM group_admins WHERE group_id = ? AND user_id = ?",
-            (group_id, user_id),
-        )
-        return cur.rowcount > 0
-
-
-def is_group_admin(group_id: int, user_id: int) -> bool:
-    with get_conn() as conn:
-        row = conn.execute(
-            "SELECT 1 FROM group_admins WHERE group_id = ? AND user_id = ?",
-            (group_id, user_id),
-        ).fetchone()
-        return row is not None
-
-
-def is_group_creator(group_id: int, user_id: int) -> bool:
-    return get_group_creator_user_id(group_id) == user_id
-
-
-def get_user_by_username(username: str) -> Optional[dict]:
-    """Look up user by username (without @)."""
-    with get_conn() as conn:
-        row = conn.execute(
-            "SELECT * FROM users WHERE username = ?",
-            (username,),
-        ).fetchone()
-        return _row_to_dict(row) if row else None
-
-
-# ── Bounties ────────────────────────────────────────────────────────────────
-
-def add_bounty(
-    group_id: int | None,
-    created_by_user_id: int,
-    informed_by_username: str,
-    text: str | None,
-    link: str | None,
-    due_date_ts: int | None,
-) -> int:
-    """Add a bounty. Returns bounty id. Raises ValueError on duplicate link."""
-    with get_conn() as conn:
-        try:
-            cur = conn.execute(
-                """INSERT INTO bounties
-                   (group_id, created_by_user_id, informed_by_username, text, link, due_date_ts)
-                   VALUES (?, ?, ?, ?, ?, ?)
-                   RETURNING id""",
-                (group_id, created_by_user_id, informed_by_username, text, link, due_date_ts),
-            )
-            return cur.fetchone()["id"]
-        except sqlite3.IntegrityError as e:
-            if "UNIQUE" in str(e) and "link" in str(e):
-                raise ValueError(f"Link already exists in this group: {link}")
-            raise
-
-
-def get_bounty(bounty_id: int) -> Optional[dict]:
-    with get_conn() as conn:
-        row = conn.execute("SELECT * FROM bounties WHERE id = ?", (bounty_id,)).fetchone()
-        return _row_to_dict(row) if row else None
-
-
-def get_group_bounties(group_id: int) -> list[dict]:
-    with get_conn() as conn:
-        return [_row_to_dict(r) for r in conn.execute(
-            "SELECT * FROM bounties WHERE group_id = ? ORDER BY created_at DESC",
-            (group_id,),
-        )]
-
-
-def get_user_personal_bounties(user_id: int) -> list[dict]:
-    """Bounties created by user in DM (group_id IS NULL)."""
-    with get_conn() as conn:
-        return [_row_to_dict(r) for r in conn.execute(
-            "SELECT * FROM bounties WHERE group_id IS NULL AND created_by_user_id = ? ORDER BY created_at DESC",
-            (user_id,),
-        )]
-
-
-def update_bounty(
-    bounty_id: int,
-    text: str | None,
-    link: str | None,
-    due_date_ts: int | None,
-) -> bool:
-    """Update bounty fields. Returns True if updated. Raises ValueError on duplicate link."""
-    with get_conn() as conn:
-        try:
-            cur = conn.execute(
-                """UPDATE bounties
-                   SET text = COALESCE(?, text),
-                       link = COALESCE(?, link),
-                       due_date_ts = COALESCE(?, due_date_ts)
-                   WHERE id = ?""",
-                (text, link, due_date_ts, bounty_id),
-            )
-            return cur.rowcount > 0
-        except sqlite3.IntegrityError as e:
-            if "UNIQUE" in str(e) and "link" in str(e):
-                raise ValueError(f"Link already exists in this group: {link}")
-            raise
-
-
-def delete_bounty(bounty_id: int) -> bool:
-    with get_conn() as conn:
-        cur = conn.execute("DELETE FROM bounties WHERE id = ?", (bounty_id,))
-        return cur.rowcount > 0
-
-
-# ── Tracking ────────────────────────────────────────────────────────────────
-
-def track_bounty(user_id: int, bounty_id: int) -> bool:
-    """Add bounty to user's tracking. Returns True if newly tracked, False if already tracking."""
-    with get_conn() as conn:
-        try:
-            conn.execute(
-                "INSERT INTO user_bounty_tracking (user_id, bounty_id) VALUES (?, ?)",
-                (user_id, bounty_id),
-            )
-            return True
-        except sqlite3.IntegrityError:
-            return False
-
-
-def untrack_bounty(user_id: int, bounty_id: int) -> bool:
-    with get_conn() as conn:
-        cur = conn.execute(
-            "DELETE FROM user_bounty_tracking WHERE user_id = ? AND bounty_id = ?",
-            (user_id, bounty_id),
-        )
-        return cur.rowcount > 0
-
-
-def is_tracking(user_id: int, bounty_id: int) -> bool:
-    with get_conn() as conn:
-        row = conn.execute(
-            "SELECT 1 FROM user_bounty_tracking WHERE user_id = ? AND bounty_id = ?",
-            (user_id, bounty_id),
-        ).fetchone()
-        return row is not None
-
-
-def get_user_tracked_bounties_in_group(user_id: int, group_id: int) -> list[dict]:
-    with get_conn() as conn:
-        return [_row_to_dict(r) for r in conn.execute(
-            """SELECT b.* FROM bounties b
-               JOIN user_bounty_tracking t ON t.bounty_id = b.id
-               WHERE t.user_id = ? AND b.group_id = ?
-               ORDER BY b.created_at DESC""",
-            (user_id, group_id),
-        )]
-
-
-def get_user_tracked_bounties_personal(user_id: int) -> list[dict]:
-    """Tracked bounties where group_id IS NULL (personal)."""
-    with get_conn() as conn:
-        return [_row_to_dict(r) for r in conn.execute(
-            """SELECT b.* FROM bounties b
-               JOIN user_bounty_tracking t ON t.bounty_id = b.id
-               WHERE t.user_id = ? AND b.group_id IS NULL
-               ORDER BY b.created_at DESC""",
-            (user_id,),
-        )]
-
-
-# ── Reminders ───────────────────────────────────────────────────────────────
-
-def get_bounties_due_soon(user_id: int, days: int = 7) -> list[dict]:
-    """Get tracked bounties with due_date within `days` that haven't been reminded yet."""
-    now = int(time.time())
-    deadline = now + days * 86400
-    with get_conn() as conn:
-        return [_row_to_dict(r) for r in conn.execute(
-            """SELECT b.*, u.username, u.telegram_user_id FROM bounties b
-               JOIN user_bounty_tracking t ON t.bounty_id = b.id
-               JOIN users u ON u.id = b.created_by_user_id
-               WHERE t.user_id = ?
-                 AND b.due_date_ts IS NOT NULL
-                 AND b.due_date_ts <= ?
-                 AND b.due_date_ts >= ?
-                 AND b.id NOT IN (
-                     SELECT bounty_id FROM reminder_log WHERE user_id = ?
-                 )
-               ORDER BY b.due_date_ts ASC""",
-            (user_id, deadline, now, user_id),
-        )]
-
-
-def log_reminder(user_id: int, bounty_id: int) -> None:
-    with get_conn() as conn:
-        conn.execute(
-            "INSERT OR IGNORE INTO reminder_log (user_id, bounty_id) VALUES (?, ?)",
-            (user_id, bounty_id),
-        )
-
-
-def get_all_user_ids() -> list[int]:
-    with get_conn() as conn:
-        return [row["telegram_user_id"] for row in conn.execute("SELECT telegram_user_id FROM users")]

apps/telegram-bot/schema.sql

@@ -1,49 +0,0 @@
--- JIGAIDO Database Schema
-
-CREATE TABLE IF NOT EXISTS groups (
-    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-    telegram_chat_id INTEGER UNIQUE NOT NULL,
-    creator_user_id  INTEGER NOT NULL,
-    created_at       INTEGER NOT NULL DEFAULT (unixepoch())
-);
-
-CREATE TABLE IF NOT EXISTS group_admins (
-    group_id  INTEGER REFERENCES groups(id) ON DELETE CASCADE,
-    user_id   INTEGER NOT NULL,
-    PRIMARY KEY (group_id, user_id)
-);
-
-CREATE TABLE IF NOT EXISTS users (
-    id               INTEGER PRIMARY KEY AUTOINCREMENT,
-    telegram_user_id  INTEGER UNIQUE NOT NULL,
-    username          TEXT,
-    created_at        INTEGER NOT NULL DEFAULT (unixepoch())
-);
-
-CREATE TABLE IF NOT EXISTS bounties (
-    id                   INTEGER PRIMARY KEY AUTOINCREMENT,
-    group_id              INTEGER REFERENCES groups(id) ON DELETE CASCADE,
-    created_by_user_id    INTEGER REFERENCES users(id),
-    informed_by_username  TEXT NOT NULL,
-    text                  TEXT,
-    link                  TEXT,
-    due_date_ts           INTEGER,
-    created_at            INTEGER NOT NULL DEFAULT (unixepoch()),
-    UNIQUE(group_id, link)
-);
-
-CREATE TABLE IF NOT EXISTS user_bounty_tracking (
-    id         INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-    bounty_id  INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
-    added_at   INTEGER NOT NULL DEFAULT (unixepoch()),
-    UNIQUE(user_id, bounty_id)
-);
-
-CREATE TABLE IF NOT EXISTS reminder_log (
-    id          INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id     INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-    bounty_id   INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
-    reminded_at INTEGER NOT NULL DEFAULT (unixepoch()),
-    UNIQUE(user_id, bounty_id)
-);

apps/telegram-bot/storage.py

@@ -0,0 +1,49 @@
+"""Per-user JSON file storage for JIGAIDO."""
+
+import json
+import tempfile
+import os
+from pathlib import Path
+from typing import Optional
+
+DATA_DIR = Path(__file__).parent / "data"
+USERS_DIR = DATA_DIR / "users"
+
+
+def _ensure_dirs() -> None:
+    USERS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _user_file_path(telegram_user_id: int) -> Path:
+    return USERS_DIR / f"{telegram_user_id}.json"
+
+
+def load_user(telegram_user_id: int) -> dict:
+    """Load user data from JSON file. Returns empty user structure if not found."""
+    _ensure_dirs()
+    path = _user_file_path(telegram_user_id)
+    if not path.exists():
+        return {
+            "user_id": telegram_user_id,
+            "username": None,
+            "personal_bounties": [],
+            "tracked_bounties": [],
+        }
+    with open(path) as f:
+        return json.load(f)
+
+
+def save_user(user_data: dict) -> None:
+    """Atomically save user data to JSON file."""
+    _ensure_dirs()
+    path = _user_file_path(user_data["user_id"])
+    with tempfile.NamedTemporaryFile(mode="w", dir=USERS_DIR, delete=False) as tmp:
+        json.dump(user_data, tmp, indent=2)
+        tmp_path = tmp.name
+    os.rename(tmp_path, path)
+
+
+def next_bounty_id(user_data: dict) -> int:
+    """Get next sequential bounty ID for user's file."""
+    existing_ids = [b["id"] for b in user_data.get("personal_bounties", [])]
+    return (max(existing_ids) + 1) if existing_ids else 1

apps/telegram-bot/tests/test_db.py

@@ -1,298 +0,0 @@
-"""Tests for db.py"""
-
-import time
-import pytest
-import db as _db
-
-
-class TestUsers:
-    def test_upsert_user_creates_new(self):
-        uid = _db.upsert_user(123, "alice")
-        assert uid > 0
-        row = _db.get_user_by_telegram_id(123)
-        assert row is not None
-        assert row["telegram_user_id"] == 123
-        assert row["username"] == "alice"
-
-    def test_upsert_user_updates_username(self):
-        # Two upserts to the same telegram_user_id: second one updates the username.
-        # Returns the same id both times (idempotent).
-        uid1 = _db.upsert_user(123, "alice")
-        uid2 = _db.upsert_user(123, "alice_updated")
-        assert uid1 == uid2
-        row = _db.get_user_by_telegram_id(123)
-        assert row["username"] == "alice_updated"
-
-    def test_get_user_by_telegram_id_not_found(self):
-        row = _db.get_user_by_telegram_id(999999)
-        assert row is None
-
-
-class TestGroups:
-    def test_upsert_group_creates_new(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-        assert gid > 0
-        row = _db.get_group(-100123)
-        assert row is not None
-        assert row["telegram_chat_id"] == -100123
-        assert row["creator_user_id"] == uid
-
-    def test_upsert_group_idempotent(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid1 = _db.upsert_group(-100123, uid)
-        gid2 = _db.upsert_group(-100123, uid)
-        assert gid1 == gid2
-
-    def test_get_group_creator_user_id(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        _db.upsert_group(-100123, uid)
-        assert _db.get_group_creator_user_id(_db.get_group(-100123)["id"]) == uid
-
-    def test_get_group_not_found(self, fresh_db):
-        row = _db.get_group(-999999)
-        assert row is None
-
-
-class TestGroupAdmins:
-    def test_add_remove_is_admin(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-
-        assert not _db.is_group_admin(gid, uid)
-        added = _db.add_group_admin(gid, uid)
-        assert added is True
-        assert _db.is_group_admin(gid, uid) is True
-
-        # Adding again returns False (already admin)
-        assert _db.add_group_admin(gid, uid) is False
-
-        removed = _db.remove_group_admin(gid, uid)
-        assert removed is True
-        assert _db.is_group_admin(gid, uid) is False
-
-    def test_remove_nonexistent_admin_returns_false(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-        assert _db.remove_group_admin(gid, uid) is False
-
-    def test_is_group_creator(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        other = _db.upsert_user(2, "other")
-        gid = _db.upsert_group(-100123, uid)
-        _db.add_group_admin(gid, uid)
-
-        assert _db.is_group_creator(gid, uid) is True
-        assert _db.is_group_creator(gid, other) is False
-
-    def test_get_user_by_username(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        row = _db.get_user_by_username("alice")
-        assert row is not None
-        assert row["id"] == uid
-        assert _db.get_user_by_username("nobody") is None
-
-
-class TestBounties:
-    def test_add_bounty_group(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-        _db.add_group_admin(gid, uid)
-
-        bid = _db.add_bounty(
-            group_id=gid,
-            created_by_user_id=uid,
-            informed_by_username="bob",
-            text="Fix bug",
-            link="https://github.com/bob/repo",
-            due_date_ts=int(time.time()) + 86400,
-        )
-        assert bid > 0
-        bounty = _db.get_bounty(bid)
-        assert bounty["text"] == "Fix bug"
-        assert bounty["link"] == "https://github.com/bob/repo"
-        assert bounty["informed_by_username"] == "bob"
-        assert bounty["group_id"] == gid
-
-    def test_add_bounty_personal(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        bid = _db.add_bounty(
-            group_id=None,
-            created_by_user_id=uid,
-            informed_by_username="alice",
-            text="Personal reminder",
-            link=None,
-            due_date_ts=None,
-        )
-        assert bid > 0
-        bounty = _db.get_bounty(bid)
-        assert bounty["group_id"] is None
-        assert bounty["text"] == "Personal reminder"
-
-    def test_add_bounty_duplicate_link_rejected(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-
-        _db.add_bounty(gid, uid, "user1", "text1", "https://example.com", None)
-        with pytest.raises(ValueError, match="Link already exists"):
-            _db.add_bounty(gid, uid, "user2", "text2", "https://example.com", None)
-
-    def test_add_bounty_null_link_allows_multiples(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-
-        bid1 = _db.add_bounty(gid, uid, "user1", "text only 1", None, None)
-        bid2 = _db.add_bounty(gid, uid, "user2", "text only 2", None, None)
-        assert bid1 != bid2
-
-    def test_get_group_bounties(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-        _db.add_group_admin(gid, uid)
-
-        _db.add_bounty(gid, uid, "user", "bounty1", None, None)
-        _db.add_bounty(gid, uid, "user", "bounty2", None, None)
-
-        bounties = _db.get_group_bounties(gid)
-        assert len(bounties) == 2
-
-    def test_get_user_personal_bounties(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        _db.add_bounty(None, uid, "alice", "personal1", None, None)
-        _db.add_bounty(None, uid, "alice", "personal2", None, None)
-
-        # Group bounty should not appear
-        other = _db.upsert_user(2, "bob")
-        gid = _db.upsert_group(-100, other)
-        _db.add_bounty(gid, other, "bob", "group bounty", None, None)
-
-        personal = _db.get_user_personal_bounties(uid)
-        assert len(personal) == 2
-
-    def test_update_bounty(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-        bid = _db.add_bounty(gid, uid, "user", "old text", None, None)
-
-        _db.update_bounty(bid, "new text", None, None)
-        updated = _db.get_bounty(bid)
-        assert updated["text"] == "new text"
-
-    def test_update_bounty_duplicate_link_rejected(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-        _db.add_bounty(gid, uid, "user1", "bounty1", "https://a.com", None)
-        bid2 = _db.add_bounty(gid, uid, "user2", "bounty2", None, None)
-
-        with pytest.raises(ValueError, match="Link already exists"):
-            _db.update_bounty(bid2, None, "https://a.com", None)
-
-    def test_delete_bounty(self, fresh_db):
-        uid = _db.upsert_user(1, "creator")
-        gid = _db.upsert_group(-100123, uid)
-        bid = _db.add_bounty(gid, uid, "user", "to delete", None, None)
-
-        assert _db.delete_bounty(bid) is True
-        assert _db.get_bounty(bid) is None
-        # Deleting again returns False
-        assert _db.delete_bounty(bid) is False
-
-
-class TestTracking:
-    def test_track_untrack_is_tracking(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        uid2 = _db.upsert_user(2, "bob")
-        gid = _db.upsert_group(-100123, uid)
-        bid = _db.add_bounty(gid, uid, "alice", "task", None, None)
-
-        assert _db.track_bounty(uid, bid) is True
-        assert _db.is_tracking(uid, bid) is True
-        # Track again → False (already tracking)
-        assert _db.track_bounty(uid, bid) is False
-
-        # Other user tracking same bounty
-        assert _db.track_bounty(uid2, bid) is True
-        assert _db.is_tracking(uid2, bid) is True
-
-        # Untrack
-        assert _db.untrack_bounty(uid, bid) is True
-        assert _db.is_tracking(uid, bid) is False
-        assert _db.is_tracking(uid2, bid) is True  # other user still tracking
-        # Untrack again → False
-        assert _db.untrack_bounty(uid, bid) is False
-
-    def test_get_user_tracked_bounties_in_group(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        gid = _db.upsert_group(-100123, uid)
-        bid1 = _db.add_bounty(gid, uid, "alice", "task1", None, None)
-        bid2 = _db.add_bounty(gid, uid, "alice", "task2", None, None)
-
-        # Different group bounty
-        other_gid = _db.upsert_group(-100124, uid)
-        bid3 = _db.add_bounty(other_gid, uid, "alice", "other group task", None, None)
-
-        _db.track_bounty(uid, bid1)
-        _db.track_bounty(uid, bid3)
-
-        tracked = _db.get_user_tracked_bounties_in_group(uid, gid)
-        assert len(tracked) == 1
-        assert tracked[0]["id"] == bid1
-
-    def test_get_user_tracked_bounties_personal(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        bid1 = _db.add_bounty(None, uid, "alice", "personal1", None, None)
-        bid2 = _db.add_bounty(None, uid, "alice", "personal2", None, None)
-
-        gid = _db.upsert_group(-100123, uid)
-        bid3 = _db.add_bounty(gid, uid, "alice", "group task", None, None)
-
-        _db.track_bounty(uid, bid1)
-        _db.track_bounty(uid, bid3)
-
-        tracked = _db.get_user_tracked_bounties_personal(uid)
-        assert len(tracked) == 1
-        assert tracked[0]["id"] == bid1
-
-
-class TestReminders:
-    def test_get_bounties_due_soon(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        gid = _db.upsert_group(-100123, uid)
-
-        now = int(time.time())
-        # Due in 3 days (< 7 days)
-        bid_soon = _db.add_bounty(gid, uid, "alice", "soon", None, now + 3 * 86400)
-        # Due in 10 days (> 7 days)
-        _db.add_bounty(gid, uid, "alice", "later", None, now + 10 * 86400)
-        # No due date
-        bid_no_date = _db.add_bounty(gid, uid, "alice", "no date", None, None)
-
-        _db.track_bounty(uid, bid_soon)
-        _db.track_bounty(uid, bid_no_date)
-
-        due = _db.get_bounties_due_soon(uid, days=7)
-        assert len(due) == 1
-        assert due[0]["id"] == bid_soon
-
-    def test_reminder_log_prevents_duplicate_reminders(self, fresh_db):
-        uid = _db.upsert_user(1, "alice")
-        gid = _db.upsert_group(-100123, uid)
-        now = int(time.time())
-        bid = _db.add_bounty(gid, uid, "alice", "task", None, now + 2 * 86400)
-        _db.track_bounty(uid, bid)
-
-        due1 = _db.get_bounties_due_soon(uid, days=7)
-        assert len(due1) == 1
-
-        # Log that we reminded
-        _db.log_reminder(uid, bid)
-
-        # Should not appear again
-        due2 = _db.get_bounties_due_soon(uid, days=7)
-        assert len(due2) == 0
-
-    def test_get_all_user_ids(self, fresh_db):
-        _db.upsert_user(1, "alice")
-        _db.upsert_user(2, "bob")
-        ids = _db.get_all_user_ids()
-        assert sorted(ids) == [1, 2]