cord-bot 1.0.2

package/.env.example

@@ -0,0 +1,15 @@
+# Required
+DISCORD_BOT_TOKEN=your-bot-token-here
+
+# Optional - Redis connection
+REDIS_HOST=localhost
+REDIS_PORT=6379
+
+# Optional - Claude configuration
+CLAUDE_WORKING_DIR=/path/to/your/project
+
+# Optional - Database
+DB_PATH=./data/threads.db
+
+# Optional - Timezone for datetime injection
+TZ=America/New_York

package/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "files.exclude": {
+        "**/.git": true,
+        "**/.svn": true,
+        "**/.hg": true,
+        "**/CVS": true,
+        "**/.DS_Store": true,
+        "**/Thumbs.db": true
+    },
+    "hide-files.files": []
+}

package/README.md

@@ -0,0 +1,113 @@
+# Cord
+
+A simple bridge that connects Discord to Claude Code CLI.
+
+> **cord** /kôrd/ — a connection between two things.
+
+When someone @mentions your bot, it:
+1. Creates a thread for the conversation
+2. Queues the message for Claude processing
+3. Posts Claude's response back to the thread
+4. Remembers context for follow-up messages
+
+## Architecture
+
+```
+Discord Bot  →  BullMQ Queue  →  Claude Spawner
+ (Node.js)       (Redis)          (Bun)
+```
+
+- **Bot** (`src/bot.ts`): Catches @mentions, creates threads, sends to queue
+- **Queue** (`src/queue.ts`): BullMQ job queue for reliable processing
+- **Worker** (`src/worker.ts`): Pulls jobs, spawns Claude, posts responses
+- **Spawner** (`src/spawner.ts`): The Claude CLI integration (the core)
+- **DB** (`src/db.ts`): SQLite for thread→session mapping
+
+## Prerequisites
+
+- [Bun](https://bun.sh) runtime
+- [Redis](https://redis.io) server
+- [Claude Code CLI](https://claude.ai/code) installed and authenticated
+- Discord bot token (see setup below)
+
+## Discord Bot Setup
+
+1. Go to [Discord Developer Portal](https://discord.com/developers/applications)
+2. Click **New Application**, give it a name
+3. Go to **Bot** tab → Click **Add Bot**
+4. Under **Privileged Gateway Intents**, enable:
+   - **Message Content Intent** (required to read message text)
+5. Click **Reset Token** → Copy the token (this is your `DISCORD_BOT_TOKEN`)
+6. Go to **OAuth2** → **URL Generator**:
+   - Scopes: `bot`
+   - Bot Permissions: `Send Messages`, `Create Public Threads`, `Send Messages in Threads`, `Read Message History`
+7. Copy the generated URL → Open in browser → Invite bot to your server
+
+**Note:** This runs 100% locally. The bot connects *outbound* to Discord's gateway - no need to expose ports or use ngrok.
+
+## Quick Start
+
+```bash
+# Install dependencies
+bun install
+
+# Set environment variables
+export DISCORD_BOT_TOKEN="your-bot-token"
+
+# Start Redis (if not already running)
+redis-server &
+
+# Start the bot and worker
+bun run src/bot.ts &
+bun run src/worker.ts
+```
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `DISCORD_BOT_TOKEN` | Yes | - | Your Discord bot token |
+| `REDIS_HOST` | No | `localhost` | Redis server host |
+| `REDIS_PORT` | No | `6379` | Redis server port |
+| `CLAUDE_WORKING_DIR` | No | `cwd` | Working directory for Claude |
+| `DB_PATH` | No | `./data/threads.db` | SQLite database path |
+
+## How It Works
+
+### New Mentions
+
+1. User @mentions the bot with a question
+2. Bot creates a thread from the message
+3. Bot generates a UUID session ID
+4. Bot stores thread_id → session_id in SQLite
+5. Bot queues a job with the prompt and session ID
+6. Worker picks up the job
+7. Worker spawns Claude with `--session-id UUID`
+8. Worker posts Claude's response to the thread
+
+### Follow-up Messages
+
+1. User sends another message in the thread
+2. Bot looks up the session ID from SQLite
+3. Bot queues a job with `resume: true`
+4. Worker spawns Claude with `--resume UUID`
+5. Claude has full context from previous messages
+
+## Key CLI Flags
+
+The magic is in `src/spawner.ts`:
+
+```typescript
+// For new sessions:
+claude --print --session-id UUID -p "prompt"
+
+// For follow-ups:
+claude --print --resume UUID -p "prompt"
+
+// Inject context that survives compaction:
+claude --append-system-prompt "Current time: ..."
+```
+
+## License
+
+MIT

package/bin/cord.ts

@@ -0,0 +1,224 @@
+#!/usr/bin/env bun
+/**
+ * Cord CLI - Manage your Discord-Claude bridge
+ *
+ * Commands:
+ *   cord start   - Start bot and worker
+ *   cord stop    - Stop all processes
+ *   cord status  - Show running status
+ *   cord logs    - Show combined logs
+ *   cord setup   - Interactive setup wizard
+ */
+
+import { spawn, spawnSync } from 'bun';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import * as readline from 'readline';
+
+const PID_FILE = join(process.cwd(), '.cord.pid');
+
+const command = process.argv[2];
+
+async function prompt(question: string): Promise<string> {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+async function setup() {
+    console.log('\n🔌 Cord Setup\n');
+
+    // Check for .env
+    const envPath = join(process.cwd(), '.env');
+    const envExamplePath = join(process.cwd(), '.env.example');
+
+    if (existsSync(envPath)) {
+        console.log('✓ .env file exists');
+    } else if (existsSync(envExamplePath)) {
+        console.log('Creating .env from .env.example...\n');
+
+        const token = await prompt('Discord Bot Token: ');
+        if (!token) {
+            console.log('Token required. Run setup again when ready.');
+            process.exit(1);
+        }
+
+        const tz = await prompt('Timezone (default: America/New_York): ') || 'America/New_York';
+
+        let envContent = readFileSync(envExamplePath, 'utf-8');
+        envContent = envContent.replace('your-bot-token-here', token);
+        envContent = envContent.replace('TZ=America/New_York', `TZ=${tz}`);
+
+        writeFileSync(envPath, envContent);
+        console.log('\n✓ .env file created');
+    }
+
+    // Check Redis
+    const redis = spawnSync(['redis-cli', 'ping'], { stdout: 'pipe', stderr: 'pipe' });
+    if (redis.exitCode === 0) {
+        console.log('✓ Redis is running');
+    } else {
+        console.log('⚠ Redis not running. Start it with: redis-server');
+    }
+
+    // Check Claude CLI
+    const claude = spawnSync(['claude', '--version'], { stdout: 'pipe', stderr: 'pipe' });
+    if (claude.exitCode === 0) {
+        console.log('✓ Claude CLI installed');
+    } else {
+        console.log('⚠ Claude CLI not found. Install from: https://claude.ai/code');
+    }
+
+    console.log('\n✨ Setup complete! Run: cord start\n');
+}
+
+async function start() {
+    if (existsSync(PID_FILE)) {
+        console.log('Cord is already running. Run: cord stop');
+        process.exit(1);
+    }
+
+    console.log('Starting Cord...\n');
+
+    // Start bot
+    const bot = spawn(['bun', 'run', 'src/bot.ts'], {
+        stdout: 'inherit',
+        stderr: 'inherit',
+        cwd: process.cwd(),
+    });
+
+    // Start worker
+    const worker = spawn(['bun', 'run', 'src/worker.ts'], {
+        stdout: 'inherit',
+        stderr: 'inherit',
+        cwd: process.cwd(),
+    });
+
+    // Save PIDs
+    writeFileSync(PID_FILE, JSON.stringify({
+        bot: bot.pid,
+        worker: worker.pid,
+        startedAt: new Date().toISOString(),
+    }));
+
+    console.log(`Bot PID: ${bot.pid}`);
+    console.log(`Worker PID: ${worker.pid}`);
+    console.log('\nCord is running. Press Ctrl+C to stop.\n');
+
+    // Handle exit
+    process.on('SIGINT', () => {
+        console.log('\nStopping Cord...');
+        bot.kill();
+        worker.kill();
+        if (existsSync(PID_FILE)) {
+            const fs = require('fs');
+            fs.unlinkSync(PID_FILE);
+        }
+        process.exit(0);
+    });
+
+    // Wait for processes
+    await Promise.all([bot.exited, worker.exited]);
+}
+
+function stop() {
+    if (!existsSync(PID_FILE)) {
+        console.log('Cord is not running.');
+        return;
+    }
+
+    const pids = JSON.parse(readFileSync(PID_FILE, 'utf-8'));
+
+    try {
+        process.kill(pids.bot);
+        console.log(`Stopped bot (PID ${pids.bot})`);
+    } catch {}
+
+    try {
+        process.kill(pids.worker);
+        console.log(`Stopped worker (PID ${pids.worker})`);
+    } catch {}
+
+    const fs = require('fs');
+    fs.unlinkSync(PID_FILE);
+    console.log('Cord stopped.');
+}
+
+function status() {
+    if (!existsSync(PID_FILE)) {
+        console.log('Cord is not running.');
+        return;
+    }
+
+    const pids = JSON.parse(readFileSync(PID_FILE, 'utf-8'));
+
+    const botAlive = isProcessRunning(pids.bot);
+    const workerAlive = isProcessRunning(pids.worker);
+
+    console.log(`Bot:    ${botAlive ? '✓ running' : '✗ stopped'} (PID ${pids.bot})`);
+    console.log(`Worker: ${workerAlive ? '✓ running' : '✗ stopped'} (PID ${pids.worker})`);
+    console.log(`Started: ${pids.startedAt}`);
+}
+
+function isProcessRunning(pid: number): boolean {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function showHelp() {
+    console.log(`
+Cord - Discord to Claude Code bridge
+
+Usage: cord <command>
+
+Commands:
+  start   Start bot and worker
+  stop    Stop all processes
+  status  Show running status
+  setup   Interactive setup wizard
+  help    Show this help
+
+Examples:
+  cord setup    # First-time configuration
+  cord start    # Start the bot
+  cord status   # Check if running
+  cord stop     # Stop everything
+`);
+}
+
+// Main
+switch (command) {
+    case 'start':
+        start();
+        break;
+    case 'stop':
+        stop();
+        break;
+    case 'status':
+        status();
+        break;
+    case 'setup':
+        setup();
+        break;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+        showHelp();
+        break;
+    default:
+        console.log(`Unknown command: ${command}`);
+        showHelp();
+        process.exit(1);
+}

package/bun.lock

@@ -0,0 +1,131 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "discord-claude-bridge",
+      "dependencies": {
+        "bullmq": "^5.67.1",
+        "discord.js": "^14.25.1",
+        "ioredis": "^5.9.2",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@discordjs/builders": ["@discordjs/builders@1.13.1", "", { "dependencies": { "@discordjs/formatters": "^0.6.2", "@discordjs/util": "^1.2.0", "@sapphire/shapeshift": "^4.0.0", "discord-api-types": "^0.38.33", "fast-deep-equal": "^3.1.3", "ts-mixer": "^6.0.4", "tslib": "^2.6.3" } }, "sha512-cOU0UDHc3lp/5nKByDxkmRiNZBpdp0kx55aarbiAfakfKJHlxv/yFW1zmIqCAmwH5CRlrH9iMFKJMpvW4DPB+w=="],
+
+    "@discordjs/collection": ["@discordjs/collection@1.5.3", "", {}, "sha512-SVb428OMd3WO1paV3rm6tSjM4wC+Kecaa1EUGX7vc6/fddvw/6lg90z4QtCqm21zvVe92vMMDt9+DkIvjXImQQ=="],
+
+    "@discordjs/formatters": ["@discordjs/formatters@0.6.2", "", { "dependencies": { "discord-api-types": "^0.38.33" } }, "sha512-y4UPwWhH6vChKRkGdMB4odasUbHOUwy7KL+OVwF86PvT6QVOwElx+TiI1/6kcmcEe+g5YRXJFiXSXUdabqZOvQ=="],
+
+    "@discordjs/rest": ["@discordjs/rest@2.6.0", "", { "dependencies": { "@discordjs/collection": "^2.1.1", "@discordjs/util": "^1.1.1", "@sapphire/async-queue": "^1.5.3", "@sapphire/snowflake": "^3.5.3", "@vladfrangu/async_event_emitter": "^2.4.6", "discord-api-types": "^0.38.16", "magic-bytes.js": "^1.10.0", "tslib": "^2.6.3", "undici": "6.21.3" } }, "sha512-RDYrhmpB7mTvmCKcpj+pc5k7POKszS4E2O9TYc+U+Y4iaCP+r910QdO43qmpOja8LRr1RJ0b3U+CqVsnPqzf4w=="],
+
+    "@discordjs/util": ["@discordjs/util@1.2.0", "", { "dependencies": { "discord-api-types": "^0.38.33" } }, "sha512-3LKP7F2+atl9vJFhaBjn4nOaSWahZ/yWjOvA4e5pnXkt2qyXRCHLxoBQy81GFtLGCq7K9lPm9R517M1U+/90Qg=="],
+
+    "@discordjs/ws": ["@discordjs/ws@1.2.3", "", { "dependencies": { "@discordjs/collection": "^2.1.0", "@discordjs/rest": "^2.5.1", "@discordjs/util": "^1.1.0", "@sapphire/async-queue": "^1.5.2", "@types/ws": "^8.5.10", "@vladfrangu/async_event_emitter": "^2.2.4", "discord-api-types": "^0.38.1", "tslib": "^2.6.2", "ws": "^8.17.0" } }, "sha512-wPlQDxEmlDg5IxhJPuxXr3Vy9AjYq5xCvFWGJyD7w7Np8ZGu+Mc+97LCoEc/+AYCo2IDpKioiH0/c/mj5ZR9Uw=="],
+
+    "@ioredis/commands": ["@ioredis/commands@1.5.0", "", {}, "sha512-eUgLqrMf8nJkZxT24JvVRrQya1vZkQh8BBeYNwGDqa5I0VUi8ACx7uFvAaLxintokpTenkK6DASvo/bvNbBGow=="],
+
+    "@msgpackr-extract/msgpackr-extract-darwin-arm64": ["@msgpackr-extract/msgpackr-extract-darwin-arm64@3.0.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-QZHtlVgbAdy2zAqNA9Gu1UpIuI8Xvsd1v8ic6B2pZmeFnFcMWiPLfWXh7TVw4eGEZ/C9TH281KwhVoeQUKbyjw=="],
+
+    "@msgpackr-extract/msgpackr-extract-darwin-x64": ["@msgpackr-extract/msgpackr-extract-darwin-x64@3.0.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-mdzd3AVzYKuUmiWOQ8GNhl64/IoFGol569zNRdkLReh6LRLHOXxU4U8eq0JwaD8iFHdVGqSy4IjFL4reoWCDFw=="],
+
+    "@msgpackr-extract/msgpackr-extract-linux-arm": ["@msgpackr-extract/msgpackr-extract-linux-arm@3.0.3", "", { "os": "linux", "cpu": "arm" }, "sha512-fg0uy/dG/nZEXfYilKoRe7yALaNmHoYeIoJuJ7KJ+YyU2bvY8vPv27f7UKhGRpY6euFYqEVhxCFZgAUNQBM3nw=="],
+
+    "@msgpackr-extract/msgpackr-extract-linux-arm64": ["@msgpackr-extract/msgpackr-extract-linux-arm64@3.0.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-YxQL+ax0XqBJDZiKimS2XQaf+2wDGVa1enVRGzEvLLVFeqa5kx2bWbtcSXgsxjQB7nRqqIGFIcLteF/sHeVtQg=="],
+
+    "@msgpackr-extract/msgpackr-extract-linux-x64": ["@msgpackr-extract/msgpackr-extract-linux-x64@3.0.3", "", { "os": "linux", "cpu": "x64" }, "sha512-cvwNfbP07pKUfq1uH+S6KJ7dT9K8WOE4ZiAcsrSes+UY55E/0jLYc+vq+DO7jlmqRb5zAggExKm0H7O/CBaesg=="],
+
+    "@msgpackr-extract/msgpackr-extract-win32-x64": ["@msgpackr-extract/msgpackr-extract-win32-x64@3.0.3", "", { "os": "win32", "cpu": "x64" }, "sha512-x0fWaQtYp4E6sktbsdAqnehxDgEc/VwM7uLsRCYWaiGu0ykYdZPiS8zCWdnjHwyiumousxfBm4SO31eXqwEZhQ=="],
+
+    "@sapphire/async-queue": ["@sapphire/async-queue@1.5.5", "", {}, "sha512-cvGzxbba6sav2zZkH8GPf2oGk9yYoD5qrNWdu9fRehifgnFZJMV+nuy2nON2roRO4yQQ+v7MK/Pktl/HgfsUXg=="],
+
+    "@sapphire/shapeshift": ["@sapphire/shapeshift@4.0.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "lodash": "^4.17.21" } }, "sha512-d9dUmWVA7MMiKobL3VpLF8P2aeanRTu6ypG2OIaEv/ZHH/SUQ2iHOVyi5wAPjQ+HmnMuL0whK9ez8I/raWbtIg=="],
+
+    "@sapphire/snowflake": ["@sapphire/snowflake@3.5.3", "", {}, "sha512-jjmJywLAFoWeBi1W7994zZyiNWPIiqRRNAmSERxyg93xRGzNYvGjlZ0gR6x0F4gPRi2+0O6S71kOZYyr3cxaIQ=="],
+
+    "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
+
+    "@types/node": ["@types/node@25.0.10", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-zWW5KPngR/yvakJgGOmZ5vTBemDoSqF3AcV/LrO5u5wTWyEAVVh+IT39G4gtyAkh3CtTZs8aX/yRM82OfzHJRg=="],
+
+    "@types/ws": ["@types/ws@8.18.1", "", { "dependencies": { "@types/node": "*" } }, "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg=="],
+
+    "@vladfrangu/async_event_emitter": ["@vladfrangu/async_event_emitter@2.4.7", "", {}, "sha512-Xfe6rpCTxSxfbswi/W/Pz7zp1WWSNn4A0eW4mLkQUewCrXXtMj31lCg+iQyTkh/CkusZSq9eDflu7tjEDXUY6g=="],
+
+    "bullmq": ["bullmq@5.67.1", "", { "dependencies": { "cron-parser": "4.9.0", "ioredis": "5.9.2", "msgpackr": "1.11.5", "node-abort-controller": "3.1.1", "semver": "7.7.3", "tslib": "2.8.1", "uuid": "11.1.0" } }, "sha512-ELJEAzwzesgFxk29emvnAakqrwdBEhEyfZREPQ8pbG4ALVz/mk/AhfuChzxkFpJ7SfL2qclPHbiUGBZzaqcLvg=="],
+
+    "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
+
+    "cluster-key-slot": ["cluster-key-slot@1.1.2", "", {}, "sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA=="],
+
+    "cron-parser": ["cron-parser@4.9.0", "", { "dependencies": { "luxon": "^3.2.1" } }, "sha512-p0SaNjrHOnQeR8/VnfGbmg9te2kfyYSQ7Sc/j/6DtPL3JQvKxmjO9TSjNFpujqV3vEYYBvNNvXSxzyksBWAx1Q=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "denque": ["denque@2.1.0", "", {}, "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw=="],
+
+    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
+
+    "discord-api-types": ["discord-api-types@0.38.37", "", {}, "sha512-Cv47jzY1jkGkh5sv0bfHYqGgKOWO1peOrGMkDFM4UmaGMOTgOW8QSexhvixa9sVOiz8MnVOBryWYyw/CEVhj7w=="],
+
+    "discord.js": ["discord.js@14.25.1", "", { "dependencies": { "@discordjs/builders": "^1.13.0", "@discordjs/collection": "1.5.3", "@discordjs/formatters": "^0.6.2", "@discordjs/rest": "^2.6.0", "@discordjs/util": "^1.2.0", "@discordjs/ws": "^1.2.3", "@sapphire/snowflake": "3.5.3", "discord-api-types": "^0.38.33", "fast-deep-equal": "3.1.3", "lodash.snakecase": "4.1.1", "magic-bytes.js": "^1.10.0", "tslib": "^2.6.3", "undici": "6.21.3" } }, "sha512-2l0gsPOLPs5t6GFZfQZKnL1OJNYFcuC/ETWsW4VtKVD/tg4ICa9x+jb9bkPffkMdRpRpuUaO/fKkHCBeiCKh8g=="],
+
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "ioredis": ["ioredis@5.9.2", "", { "dependencies": { "@ioredis/commands": "1.5.0", "cluster-key-slot": "^1.1.0", "debug": "^4.3.4", "denque": "^2.1.0", "lodash.defaults": "^4.2.0", "lodash.isarguments": "^3.1.0", "redis-errors": "^1.2.0", "redis-parser": "^3.0.0", "standard-as-callback": "^2.1.0" } }, "sha512-tAAg/72/VxOUW7RQSX1pIxJVucYKcjFjfvj60L57jrZpYCHC3XN0WCQ3sNYL4Gmvv+7GPvTAjc+KSdeNuE8oWQ=="],
+
+    "lodash": ["lodash@4.17.23", "", {}, "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w=="],
+
+    "lodash.defaults": ["lodash.defaults@4.2.0", "", {}, "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ=="],
+
+    "lodash.isarguments": ["lodash.isarguments@3.1.0", "", {}, "sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg=="],
+
+    "lodash.snakecase": ["lodash.snakecase@4.1.1", "", {}, "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw=="],
+
+    "luxon": ["luxon@3.7.2", "", {}, "sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew=="],
+
+    "magic-bytes.js": ["magic-bytes.js@1.13.0", "", {}, "sha512-afO2mnxW7GDTXMm5/AoN1WuOcdoKhtgXjIvHmobqTD1grNplhGdv3PFOyjCVmrnOZBIT/gD/koDKpYG+0mvHcg=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "msgpackr": ["msgpackr@1.11.5", "", { "optionalDependencies": { "msgpackr-extract": "^3.0.2" } }, "sha512-UjkUHN0yqp9RWKy0Lplhh+wlpdt9oQBYgULZOiFhV3VclSF1JnSQWZ5r9gORQlNYaUKQoR8itv7g7z1xDDuACA=="],
+
+    "msgpackr-extract": ["msgpackr-extract@3.0.3", "", { "dependencies": { "node-gyp-build-optional-packages": "5.2.2" }, "optionalDependencies": { "@msgpackr-extract/msgpackr-extract-darwin-arm64": "3.0.3", "@msgpackr-extract/msgpackr-extract-darwin-x64": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-arm": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-arm64": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-x64": "3.0.3", "@msgpackr-extract/msgpackr-extract-win32-x64": "3.0.3" }, "bin": { "download-msgpackr-prebuilds": "bin/download-prebuilds.js" } }, "sha512-P0efT1C9jIdVRefqjzOQ9Xml57zpOXnIuS+csaB4MdZbTdmGDLo8XhzBG1N7aO11gKDDkJvBLULeFTo46wwreA=="],
+
+    "node-abort-controller": ["node-abort-controller@3.1.1", "", {}, "sha512-AGK2yQKIjRuqnc6VkX2Xj5d+QW8xZ87pa1UK6yA6ouUyuxfHuMP6umE5QK7UmTeOAymo+Zx1Fxiuw9rVx8taHQ=="],
+
+    "node-gyp-build-optional-packages": ["node-gyp-build-optional-packages@5.2.2", "", { "dependencies": { "detect-libc": "^2.0.1" }, "bin": { "node-gyp-build-optional-packages": "bin.js", "node-gyp-build-optional-packages-optional": "optional.js", "node-gyp-build-optional-packages-test": "build-test.js" } }, "sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw=="],
+
+    "redis-errors": ["redis-errors@1.2.0", "", {}, "sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w=="],
+
+    "redis-parser": ["redis-parser@3.0.0", "", { "dependencies": { "redis-errors": "^1.0.0" } }, "sha512-DJnGAeenTdpMEH6uAJRK/uiyEIH9WVsUmoLwzudwGJUwZPp80PDBWPHXSAGNPwNvIXAbe7MSUB1zQFugFml66A=="],
+
+    "semver": ["semver@7.7.3", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q=="],
+
+    "standard-as-callback": ["standard-as-callback@2.1.0", "", {}, "sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A=="],
+
+    "ts-mixer": ["ts-mixer@6.0.4", "", {}, "sha512-ufKpbmrugz5Aou4wcr5Wc1UUFWOLhq+Fm6qa6P0w0K5Qw2yhaUoiWszhCVuNQyNwrlGiscHOmqYoAox1PtvgjA=="],
+
+    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici": ["undici@6.21.3", "", {}, "sha512-gBLkYIlEnSp8pFbT64yFgGE6UIB9tAkhukC23PmMDCe5Nd+cRqKxSjw5y54MK2AZMgZfJWMaNE4nYUHgi1XEOw=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+
+    "uuid": ["uuid@11.1.0", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A=="],
+
+    "ws": ["ws@8.19.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg=="],
+
+    "@discordjs/rest/@discordjs/collection": ["@discordjs/collection@2.1.1", "", {}, "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg=="],
+
+    "@discordjs/ws/@discordjs/collection": ["@discordjs/collection@2.1.1", "", {}, "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg=="],
+  }
+}

package/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Cord - Discord to Claude Code bridge
+ *
+ * A simple bridge that connects Discord to Claude Code CLI.
+ *
+ * Start the bot:     bun run src/bot.ts
+ * Start the worker:  bun run src/worker.ts
+ *
+ * Or run both:       bun run start
+ */
+
+console.log('Cord - Discord to Claude Code bridge');
+console.log('');
+console.log('To start the system:');
+console.log('  1. Start Redis:      redis-server');
+console.log('  2. Start the bot:    bun run src/bot.ts');
+console.log('  3. Start the worker: bun run src/worker.ts');
+console.log('');
+console.log('Environment variables:');
+console.log('  DISCORD_BOT_TOKEN  - Your Discord bot token (required)');
+console.log('  REDIS_HOST         - Redis host (default: localhost)');
+console.log('  REDIS_PORT         - Redis port (default: 6379)');
+console.log('  CLAUDE_WORKING_DIR - Working directory for Claude (default: cwd)');
+console.log('  DB_PATH            - SQLite database path (default: ./data/threads.db)');

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "cord-bot",
+  "version": "1.0.2",
+  "module": "index.ts",
+  "type": "module",
+  "bin": {
+    "cord": "bin/cord.ts"
+  },
+  "scripts": {
+    "start": "bun run bin/cord.ts start",
+    "bot": "bun run src/bot.ts",
+    "worker": "bun run src/worker.ts",
+    "setup": "bun run bin/cord.ts setup"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "bullmq": "^5.67.1",
+    "discord.js": "^14.25.1",
+    "ioredis": "^5.9.2"
+  }
+}

package/src/bot.ts

@@ -0,0 +1,144 @@
+/**
+ * Discord Bot - Catches @mentions, creates threads, forwards to queue
+ *
+ * This is the entry point for the Discord → Claude bridge.
+ * When someone @mentions the bot, it:
+ * 1. Creates a thread for the conversation
+ * 2. Queues the message for Claude processing
+ * 3. Posts responses back to the thread
+ */
+
+import {
+    Client,
+    GatewayIntentBits,
+    Events,
+    Message,
+    TextChannel,
+    ThreadAutoArchiveDuration
+} from 'discord.js';
+import { claudeQueue } from './queue.js';
+import { db } from './db.js';
+
+// Force unbuffered logging
+const log = (msg: string) => process.stdout.write(`[bot] ${msg}\n`);
+
+const client = new Client({
+    intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+    ],
+});
+
+client.once(Events.ClientReady, (c) => {
+    log(`Logged in as ${c.user.tag}`);
+});
+
+client.on(Events.MessageCreate, async (message: Message) => {
+    // Ignore bots
+    if (message.author.bot) return;
+
+    const isMentioned = client.user && message.mentions.has(client.user);
+    const isInThread = message.channel.isThread();
+
+    // =========================================================================
+    // THREAD MESSAGES: Continue existing conversations
+    // =========================================================================
+    if (isInThread) {
+        const thread = message.channel;
+
+        // Look up session ID for this thread
+        const mapping = db.query('SELECT session_id FROM threads WHERE thread_id = ?')
+            .get(thread.id) as { session_id: string } | null;
+
+        if (!mapping) {
+            // Not a thread we created, ignore
+            return;
+        }
+
+        log(`Thread message from ${message.author.tag}`);
+
+        // Show typing indicator
+        await thread.sendTyping();
+
+        // Extract message content (strip @mentions)
+        const content = message.content.replace(/<@!?\d+>/g, '').trim();
+
+        // Queue for Claude processing with session resume
+        await claudeQueue.add('process', {
+            prompt: content,
+            threadId: thread.id,
+            sessionId: mapping.session_id,
+            resume: true,
+            userId: message.author.id,
+            username: message.author.tag,
+        });
+
+        return;
+    }
+
+    // =========================================================================
+    // NEW MENTIONS: Start new conversations
+    // =========================================================================
+    if (!isMentioned) return;
+
+    log(`New mention from ${message.author.tag}`);
+
+    // Create a thread for the conversation
+    let thread;
+    try {
+        // Generate thread name from message content
+        const rawText = message.content.replace(/<@!?\d+>/g, '').trim();
+        const threadName = rawText.length > 50
+            ? rawText.slice(0, 47) + '...'
+            : rawText || 'New conversation';
+
+        thread = await message.startThread({
+            name: threadName,
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+        });
+    } catch (error) {
+        log(`Failed to create thread: ${error}`);
+        await message.reply('Failed to start thread. Try again?');
+        return;
+    }
+
+    // Generate a new session ID for this conversation
+    const sessionId = crypto.randomUUID();
+
+    // Store the thread → session mapping
+    db.run(
+        'INSERT INTO threads (thread_id, session_id) VALUES (?, ?)',
+        [thread.id, sessionId]
+    );
+
+    log(`Created thread ${thread.id} with session ${sessionId}`);
+
+    // Show typing indicator
+    await thread.sendTyping();
+
+    // Extract message content
+    const content = message.content.replace(/<@!?\d+>/g, '').trim();
+
+    // Queue for Claude processing
+    await claudeQueue.add('process', {
+        prompt: content,
+        threadId: thread.id,
+        sessionId,
+        resume: false,
+        userId: message.author.id,
+        username: message.author.tag,
+    });
+});
+
+// Start the bot
+const token = process.env.DISCORD_BOT_TOKEN;
+if (!token) {
+    console.error('DISCORD_BOT_TOKEN required');
+    process.exit(1);
+}
+
+client.login(token);
+
+// Export for external use
+export { client };

package/src/db.ts

@@ -0,0 +1,41 @@
+/**
+ * Database - SQLite for thread → session mappings
+ *
+ * Simple key-value store:
+ * - thread_id (Discord thread ID)
+ * - session_id (Claude session UUID)
+ *
+ * When a follow-up message comes in a thread, we look up
+ * the session ID to use --resume.
+ */
+
+import { Database } from 'bun:sqlite';
+
+const DB_PATH = process.env.DB_PATH || './data/threads.db';
+
+// Ensure data directory exists
+import { mkdirSync } from 'fs';
+import { dirname } from 'path';
+try {
+    mkdirSync(dirname(DB_PATH), { recursive: true });
+} catch {}
+
+// Open database
+export const db = new Database(DB_PATH);
+
+// Create tables if they don't exist
+db.run(`
+    CREATE TABLE IF NOT EXISTS threads (
+        thread_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+`);
+
+// Create index for faster lookups
+db.run(`
+    CREATE INDEX IF NOT EXISTS idx_threads_session
+    ON threads(session_id)
+`);
+
+console.log(`[db] SQLite database ready at ${DB_PATH}`);

package/src/discord.ts

@@ -0,0 +1,80 @@
+/**
+ * Discord utilities - Helper functions for posting to Discord
+ *
+ * Separated from bot.ts so the worker can send messages
+ * without importing the full client.
+ */
+
+const DISCORD_BOT_TOKEN = process.env.DISCORD_BOT_TOKEN;
+
+if (!DISCORD_BOT_TOKEN) {
+    console.warn('[discord] DISCORD_BOT_TOKEN not set - sendToThread will fail');
+}
+
+/**
+ * Send a message to a Discord thread
+ *
+ * Uses the REST API directly so we don't need the gateway client
+ */
+export async function sendToThread(threadId: string, content: string): Promise<void> {
+    // Discord message limit is 2000 chars
+    const MAX_LENGTH = 2000;
+
+    // Split long messages
+    const chunks: string[] = [];
+    let remaining = content;
+
+    while (remaining.length > 0) {
+        if (remaining.length <= MAX_LENGTH) {
+            chunks.push(remaining);
+            break;
+        }
+
+        // Find a good split point (newline or space)
+        let splitAt = remaining.lastIndexOf('\n', MAX_LENGTH);
+        if (splitAt === -1 || splitAt < MAX_LENGTH / 2) {
+            splitAt = remaining.lastIndexOf(' ', MAX_LENGTH);
+        }
+        if (splitAt === -1 || splitAt < MAX_LENGTH / 2) {
+            splitAt = MAX_LENGTH;
+        }
+
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).trim();
+    }
+
+    // Send each chunk
+    for (const chunk of chunks) {
+        const response = await fetch(
+            `https://discord.com/api/v10/channels/${threadId}/messages`,
+            {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bot ${DISCORD_BOT_TOKEN}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ content: chunk }),
+            }
+        );
+
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Discord API error: ${response.status} ${error}`);
+        }
+    }
+}
+
+/**
+ * Send typing indicator to a thread
+ */
+export async function sendTyping(channelId: string): Promise<void> {
+    await fetch(
+        `https://discord.com/api/v10/channels/${channelId}/typing`,
+        {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bot ${DISCORD_BOT_TOKEN}`,
+            },
+        }
+    );
+}

package/src/queue.ts

@@ -0,0 +1,42 @@
+/**
+ * Queue - BullMQ job queue for Claude processing
+ *
+ * Why a queue?
+ * 1. Claude can take minutes to respond - Discord would timeout
+ * 2. Rate limiting - don't spawn 100 Claude processes at once
+ * 3. Persistence - if the bot crashes, jobs aren't lost
+ */
+
+import { Queue } from 'bullmq';
+import IORedis from 'ioredis';
+
+// Redis connection for BullMQ
+const connection = new IORedis({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    maxRetriesPerRequest: null, // Required for BullMQ
+});
+
+// The queue that holds Claude processing jobs
+export const claudeQueue = new Queue('claude', {
+    connection,
+    defaultJobOptions: {
+        attempts: 3,
+        backoff: {
+            type: 'exponential',
+            delay: 1000,
+        },
+        removeOnComplete: 100, // Keep last 100 completed jobs
+        removeOnFail: 50,      // Keep last 50 failed jobs
+    },
+});
+
+// Job data structure
+export interface ClaudeJob {
+    prompt: string;
+    threadId: string;
+    sessionId: string;
+    resume: boolean;
+    userId: string;
+    username: string;
+}

package/src/spawner.ts

@@ -0,0 +1,107 @@
+/**
+ * Spawner - The Claude CLI integration
+ *
+ * THIS IS THE CORE OF THE SYSTEM.
+ *
+ * Key flags:
+ * - `--print`: Non-interactive mode, returns output
+ * - `--session-id UUID`: Set session ID for new sessions
+ * - `--resume UUID`: Resume an existing session (for follow-ups)
+ * - `--append-system-prompt`: Inject context that survives compaction
+ * - `-p "prompt"`: The actual prompt to send
+ */
+
+const log = (msg: string) => process.stdout.write(`[spawner] ${msg}\n`);
+
+// Timezone for datetime injection (set via TZ env var)
+const TIMEZONE = process.env.TZ || 'UTC';
+
+interface SpawnOptions {
+    prompt: string;
+    sessionId: string;
+    resume: boolean;
+    systemPrompt?: string;
+}
+
+/**
+ * Get current datetime in user's timezone
+ * Claude Code doesn't know the time - we inject it
+ */
+function getDatetimeContext(): string {
+    const now = new Date();
+    return now.toLocaleString('en-US', {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true,
+        timeZone: TIMEZONE,
+    });
+}
+
+/**
+ * Spawn Claude CLI and return the response
+ */
+export async function spawnClaude(options: SpawnOptions): Promise<string> {
+    const { prompt, sessionId, resume, systemPrompt } = options;
+
+    log(`Spawning Claude - Session: ${sessionId}, Resume: ${resume}`);
+
+    // Build CLI arguments
+    const args = ['claude'];
+
+    // Non-interactive mode
+    args.push('--print');
+
+    // Session handling
+    if (resume) {
+        // Resume existing session for follow-up messages
+        args.push('--resume', sessionId);
+    } else {
+        // New session - set the ID upfront
+        args.push('--session-id', sessionId);
+    }
+
+    // Inject datetime context (survives session compaction)
+    const datetimeContext = `Current date/time: ${getDatetimeContext()}`;
+    const fullSystemPrompt = systemPrompt
+        ? `${datetimeContext}\n\n${systemPrompt}`
+        : datetimeContext;
+
+    args.push('--append-system-prompt', fullSystemPrompt);
+
+    // The actual prompt
+    args.push('-p', prompt);
+
+    log(`Command: ${args.join(' ').slice(0, 100)}...`);
+
+    // Spawn the process
+    const proc = Bun.spawn(args, {
+        cwd: process.env.CLAUDE_WORKING_DIR || process.cwd(),
+        env: {
+            ...process.env,
+            TZ: TIMEZONE,
+        },
+        stdout: 'pipe',
+        stderr: 'pipe',
+    });
+
+    // Collect output
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+
+    // Wait for process to exit
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+        log(`Claude exited with code ${exitCode}`);
+        log(`stderr: ${stderr}`);
+        throw new Error(`Claude failed: ${stderr || 'Unknown error'}`);
+    }
+
+    log(`Claude responded (${stdout.length} chars)`);
+
+    return stdout.trim();
+}

package/src/worker.ts

@@ -0,0 +1,74 @@
+/**
+ * Worker - Processes Claude jobs from the queue
+ *
+ * This is where the magic happens:
+ * 1. Pulls jobs from the queue
+ * 2. Spawns Claude CLI with the right flags
+ * 3. Posts the response back to Discord
+ */
+
+import { Worker, Job } from 'bullmq';
+import IORedis from 'ioredis';
+import { spawnClaude } from './spawner.js';
+import { sendToThread } from './discord.js';
+import type { ClaudeJob } from './queue.js';
+
+const log = (msg: string) => process.stdout.write(`[worker] ${msg}\n`);
+
+const connection = new IORedis({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    maxRetriesPerRequest: null,
+});
+
+const worker = new Worker<ClaudeJob>(
+    'claude',
+    async (job: Job<ClaudeJob>) => {
+        const { prompt, threadId, sessionId, resume, username } = job.data;
+
+        log(`Processing job ${job.id} for ${username}`);
+        log(`Session: ${sessionId}, Resume: ${resume}`);
+
+        try {
+            // Spawn Claude and get response
+            const response = await spawnClaude({
+                prompt,
+                sessionId,
+                resume,
+            });
+
+            // Send response to Discord thread
+            await sendToThread(threadId, response);
+
+            log(`Job ${job.id} completed`);
+            return { success: true, responseLength: response.length };
+
+        } catch (error) {
+            log(`Job ${job.id} failed: ${error}`);
+
+            // Send error message to thread
+            await sendToThread(
+                threadId,
+                `Something went wrong. Try again?\n\`\`\`${error}\`\`\``
+            );
+
+            throw error; // Re-throw for BullMQ retry logic
+        }
+    },
+    {
+        connection,
+        concurrency: 2, // Process up to 2 jobs at once
+    }
+);
+
+worker.on('completed', (job) => {
+    log(`Job ${job?.id} completed`);
+});
+
+worker.on('failed', (job, err) => {
+    log(`Job ${job?.id} failed: ${err.message}`);
+});
+
+log('Worker started, waiting for jobs...');
+
+export { worker };

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}