free-coding-models 0.1.82 → 0.1.84

package/src/request-transformer.js

@@ -0,0 +1,180 @@
+/**
+ * request-transformer.js
+ *
+ * Utilities for transforming outgoing API request bodies before they are
+ * forwarded to a model provider:
+ *   - applyThinkingBudget  — control Anthropic-style "thinking" budget
+ *   - compressContext      — reduce prompt size at increasing compression levels
+ */
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Count the total characters contributed by a single message.
+ * Handles both plain-string content and array-of-blocks content.
+ *
+ * @param {object} msg
+ * @returns {number}
+ */
+function messageCharCount(msg) {
+  if (typeof msg.content === 'string') return msg.content.length
+  if (Array.isArray(msg.content)) {
+    return msg.content.reduce((sum, block) => {
+      if (typeof block === 'string') return sum + block.length
+      if (block.type === 'text') return sum + (block.text?.length || 0)
+      if (block.type === 'thinking') return sum + (block.thinking?.length || 0)
+      return sum
+    }, 0)
+  }
+  return 0
+}
+
+// ---------------------------------------------------------------------------
+// applyThinkingBudget
+// ---------------------------------------------------------------------------
+
+/**
+ * Attach (or omit) an Anthropic-style "thinking" budget to the request body.
+ *
+ * Modes:
+ *   'passthrough' — return a shallow copy of body with no changes
+ *   'custom'      — add thinking: { budget_tokens: config.budget_tokens }
+ *   'auto'        — add thinking only when the total prompt is > 2 000 chars;
+ *                   budget is proportional: min(totalChars * 2, 32 000)
+ *
+ * The original body is NEVER mutated.
+ *
+ * @param {object} body        - The request body (OpenAI-compatible shape)
+ * @param {{ mode: string, budget_tokens?: number }} config
+ * @returns {object}           - A new body object
+ */
+export function applyThinkingBudget(body, config) {
+  const { mode } = config
+
+  if (mode === 'passthrough') {
+    return { ...body }
+  }
+
+  if (mode === 'custom') {
+    return { ...body, thinking: { budget_tokens: config.budget_tokens } }
+  }
+
+  if (mode === 'auto') {
+    const messages = Array.isArray(body.messages) ? body.messages : []
+    const totalChars = messages.reduce((sum, msg) => {
+      if (typeof msg.content === 'string') return sum + msg.content.length
+      if (Array.isArray(msg.content)) {
+        return sum + msg.content.reduce((s, block) => {
+          if (typeof block === 'string') return s + block.length
+          return s + (block.text?.length || 0) + (block.thinking?.length || 0)
+        }, 0)
+      }
+      return sum
+    }, 0)
+
+    if (totalChars > 2000) {
+      const budget_tokens = Math.min(Math.floor(totalChars * 2), 32000)
+      return { ...body, thinking: { budget_tokens } }
+    }
+
+    return { ...body }
+  }
+
+  // Unknown mode — return shallow copy unchanged
+  return { ...body }
+}
+
+// ---------------------------------------------------------------------------
+// compressContext
+// ---------------------------------------------------------------------------
+
+/**
+ * Reduce the size of the messages array at increasing compression levels.
+ *
+ * Levels:
+ *   0 — no change (shallow copy of array)
+ *   1 — truncate tool-result messages whose content exceeds toolResultMaxChars
+ *   2 — L1 + truncate thinking blocks in assistant messages
+ *   3 — L2 + drop oldest non-system messages when total chars exceed maxTotalChars
+ *
+ * The original messages array and its objects are NEVER mutated.
+ *
+ * @param {object[]} messages
+ * @param {{
+ *   level?: number,
+ *   toolResultMaxChars?: number,
+ *   thinkingMaxChars?: number,
+ *   maxTotalChars?: number
+ * }} opts
+ * @returns {object[]}
+ */
+export function compressContext(messages, opts = {}) {
+  const {
+    level = 0,
+    toolResultMaxChars = 4000,
+    thinkingMaxChars = 1000,
+    maxTotalChars = 100000,
+  } = opts
+
+  if (level === 0) {
+    return [...messages]
+  }
+
+  // L1: trim oversized tool results
+  let result = messages.map(msg => {
+    if (msg.role === 'tool' && typeof msg.content === 'string') {
+      if (msg.content.length > toolResultMaxChars) {
+        return {
+          ...msg,
+          content: msg.content.slice(0, toolResultMaxChars) + '\n[truncated]',
+        }
+      }
+    }
+    return msg
+  })
+
+  if (level === 1) {
+    return result
+  }
+
+  // L2: trim thinking blocks in assistant messages
+  result = result.map(msg => {
+    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+      const newContent = msg.content.map(block => {
+        if (
+          block.type === 'thinking' &&
+          typeof block.thinking === 'string' &&
+          block.thinking.length > thinkingMaxChars
+        ) {
+          return { ...block, thinking: block.thinking.slice(0, thinkingMaxChars) }
+        }
+        return block
+      })
+      // Only create a new message object when something actually changed
+      const changed = newContent.some((b, i) => b !== msg.content[i])
+      return changed ? { ...msg, content: newContent } : msg
+    }
+    return msg
+  })
+
+  if (level === 2) {
+    return result
+  }
+
+  // L3: drop oldest non-system messages until total chars is within budget
+  // Always preserve: every 'system' message, and the last message in the array.
+  const totalChars = () => result.reduce((sum, msg) => sum + messageCharCount(msg), 0)
+
+  while (totalChars() > maxTotalChars && result.length > 1) {
+    // Find the first droppable message: not 'system', not the last one
+    const dropIdx = result.findIndex(
+      (msg, idx) => msg.role !== 'system' && idx !== result.length - 1
+    )
+    if (dropIdx === -1) break // nothing left to drop
+    result = [...result.slice(0, dropIdx), ...result.slice(dropIdx + 1)]
+  }
+
+  return result
+}

package/src/setup.js

@@ -0,0 +1,105 @@
+/**
+ * @file setup.js
+ * @description First-run API key setup wizard, extracted from bin/free-coding-models.js.
+ *
+ * @details
+ *   `promptApiKey` is the interactive first-time setup wizard shown when NO provider has
+ *   a key configured yet.  It steps through every configured provider in `sources.js`
+ *   sequentially, displaying the signup URL and a hint, then asks the user to paste their
+ *   key (pressing Enter skips that provider).
+ *
+ *   The wizard is skipped on subsequent runs because `loadConfig()` finds existing keys in
+ *   ~/.free-coding-models.json and the caller (`main()`) only invokes `promptApiKey` when
+ *   `Object.values(config.apiKeys).every(v => !v)`.
+ *
+ *   ⚙️ How it works:
+ *   1. Builds a `providers` list from `Object.keys(sources)` so new providers added to
+ *      sources.js automatically appear in the wizard without any code changes here.
+ *   2. Uses `readline.createInterface` for line-at-a-time input (not raw mode).
+ *   3. Calls `saveConfig(config)` once after collecting all answers.
+ *   4. Returns the nvidia key (or the first entered key) for backward-compatibility with
+ *      the `main()` caller that originally checked for `nvidiKey !== null` before continuing.
+ *
+ * @functions
+ *   → promptApiKey(config) — Interactive multi-provider key wizard; returns first found key or null
+ *
+ * @exports
+ *   promptApiKey
+ *
+ * @see src/provider-metadata.js — PROVIDER_METADATA provides label/color/url/hint per provider
+ * @see src/config.js            — saveConfig persists the collected keys
+ * @see sources.js               — Object.keys(sources) drives the provider iteration order
+ * @see bin/free-coding-models.js — calls promptApiKey when no keys are configured
+ */
+
+import chalk from 'chalk'
+import { createRequire } from 'module'
+import { sources } from '../sources.js'
+import { PROVIDER_METADATA } from './provider-metadata.js'
+import { saveConfig } from './config.js'
+
+const require = createRequire(import.meta.url)
+const readline = require('readline')
+
+/**
+ * 📖 promptApiKey: Interactive first-run wizard for multi-provider API key setup.
+ * 📖 Shown when NO provider has a key configured yet.
+ * 📖 Steps through all configured providers sequentially — each is optional (Enter to skip).
+ * 📖 At least one key must be entered to proceed. Keys saved to ~/.free-coding-models.json.
+ * 📖 Returns the nvidia key (or null) for backward-compat with the rest of main().
+ * @param {Record<string, unknown>} config
+ * @returns {Promise<string|null>}
+ */
+export async function promptApiKey(config) {
+  console.log()
+  console.log(chalk.bold('  🔑 First-time setup — API keys'))
+  console.log(chalk.dim('  Enter keys for any provider you want to use. Press Enter to skip one.'))
+  console.log()
+
+  // 📖 Build providers from sources to keep setup in sync with actual supported providers.
+  const providers = Object.keys(sources).map((key) => {
+    const meta = PROVIDER_METADATA[key] || {}
+    return {
+      key,
+      label: meta.label || sources[key]?.name || key,
+      color: meta.color || chalk.white,
+      url: meta.signupUrl || 'https://example.com',
+      hint: meta.signupHint || 'Create API key',
+    }
+  })
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+
+  // 📖 Ask a single question — returns trimmed string or '' for skip
+  const ask = (question) => new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()))
+  })
+
+  for (const p of providers) {
+    console.log(`  ${p.color('●')} ${chalk.bold(p.label)}`)
+    console.log(chalk.dim(`    Free key at: `) + chalk.cyanBright(p.url))
+    console.log(chalk.dim(`    ${p.hint}`))
+    const answer = await ask(chalk.dim(`  Enter key (or Enter to skip): `))
+    console.log()
+    if (answer) {
+      config.apiKeys[p.key] = answer
+    }
+  }
+
+  rl.close()
+
+  // 📖 Check at least one key was entered
+  const anyKey = Object.values(config.apiKeys).some(v => v)
+  if (!anyKey) {
+    return null
+  }
+
+  saveConfig(config)
+  const savedCount = Object.values(config.apiKeys).filter(v => v).length
+  console.log(chalk.green(`  ✅ ${savedCount} key(s) saved to ~/.free-coding-models.json`))
+  console.log(chalk.dim('  You can add or change keys anytime with the ') + chalk.yellow('P') + chalk.dim(' key in the TUI.'))
+  console.log()
+
+  // 📖 Return nvidia key for backward-compat (main() checks it exists before continuing)
+  return config.apiKeys.nvidia || Object.values(config.apiKeys).find(v => v) || null
+}

package/src/telemetry.js

@@ -0,0 +1,382 @@
+/**
+ * @file telemetry.js
+ * @description Anonymous usage telemetry and Discord feedback webhooks.
+ *              Extracted from bin/free-coding-models.js to keep the main entry point lean.
+ *
+ * @details
+ *   All telemetry is strictly opt-in-by-default, fire-and-forget, and anonymous:
+ *   - A stable `anonymousId` (UUID prefixed with "anon_") is generated once and stored
+ *     in ~/.free-coding-models.json.  No personal data is ever collected.
+ *   - PostHog is used for product analytics (app_start events, mode, platform).
+ *   - Discord webhooks carry anonymous feature requests (J key) and bug reports (I key).
+ *   - `isTelemetryEnabled()` checks: CLI flag → env var → default (enabled).
+ *   - `telemetryDebug()` writes to stderr only when FREE_CODING_MODELS_TELEMETRY_DEBUG=1.
+ *   - `sendUsageTelemetry()` has a hard 1.2 s timeout so it never blocks startup.
+ *
+ *   ⚙️ Configuration (env vars, all optional):
+ *   - FREE_CODING_MODELS_TELEMETRY=0|false|off  — disable telemetry globally
+ *   - FREE_CODING_MODELS_TELEMETRY_DEBUG=1       — print debug traces to stderr
+ *   - FREE_CODING_MODELS_POSTHOG_KEY             — override the PostHog project key
+ *   - FREE_CODING_MODELS_POSTHOG_HOST            — override the PostHog host
+ *   - POSTHOG_PROJECT_API_KEY / POSTHOG_HOST     — standard PostHog env vars (fallback)
+ *
+ * @functions
+ *   → parseTelemetryEnv(value)                    — Convert env string to boolean or null
+ *   → isTelemetryDebugEnabled()                   — Check debug flag from env
+ *   → telemetryDebug(message, meta)               — Conditional debug trace to stderr
+ *   → ensureTelemetryConfig(config)               — Ensure telemetry shape in config object
+ *   → getTelemetryDistinctId(config)              — Get/create stable anonymous ID
+ *   → getTelemetrySystem()                        — Convert platform to human label
+ *   → getTelemetryTerminal()                      — Infer terminal family from env hints
+ *   → isTelemetryEnabled(config, cliArgs)         — Resolve effective enabled state
+ *   → sendUsageTelemetry(config, cliArgs, payload)— Fire-and-forget PostHog ping
+ *   → sendFeatureRequest(message)                 — Post anonymous feature request to Discord
+ *   → sendBugReport(message)                      — Post anonymous bug report to Discord
+ *
+ * @exports
+ *   parseTelemetryEnv, isTelemetryDebugEnabled, telemetryDebug,
+ *   ensureTelemetryConfig, getTelemetryDistinctId,
+ *   getTelemetrySystem, getTelemetryTerminal,
+ *   isTelemetryEnabled, sendUsageTelemetry,
+ *   sendFeatureRequest, sendBugReport
+ *
+ * @see src/config.js  — saveConfig is imported here to persist the generated anonymousId
+ * @see bin/free-coding-models.js — calls sendUsageTelemetry on startup and on key events
+ */
+
+import { randomUUID } from 'crypto'
+import { createRequire } from 'module'
+import { saveConfig } from './config.js'
+
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json')
+const LOCAL_VERSION = pkg.version
+
+// 📖 PostHog capture endpoint and defaults.
+// 📖 These are public ingest tokens — safe to publish in open-source code.
+const TELEMETRY_TIMEOUT          = 1_200
+const POSTHOG_CAPTURE_PATH       = '/i/v0/e/'
+const POSTHOG_DEFAULT_HOST       = 'https://eu.i.posthog.com'
+const POSTHOG_PROJECT_KEY_DEFAULT = 'phc_5P1n8HaLof6nHM0tKJYt4bV5pj2XPb272fLVigwf1YQ'
+const POSTHOG_HOST_DEFAULT       = 'https://eu.i.posthog.com'
+
+// 📖 Discord feature request webhook configuration (anonymous feedback system).
+const DISCORD_WEBHOOK_URL   = 'https://discord.com/api/webhooks/1476709155992764427/hmnHNtpducvi5LClhv8DynENjUmmg9q8HI1Bx1lNix56UHqrqZf55rW95LGvNJ2W4j7D'
+const DISCORD_BOT_NAME      = 'TUI - Feature Requests'
+const DISCORD_EMBED_COLOR   = 0x39FF14  // Vert fluo (RGB: 57, 255, 20)
+
+// 📖 Discord bug report webhook configuration (anonymous bug reports).
+const DISCORD_BUG_WEBHOOK_URL  = 'https://discord.com/api/webhooks/1476715954409963743/5cOLf7U_891f1jwxRBLIp2RIP9xYhr4rWtOhipzKKwVdFVl1Bj89X_fB6I_uGXZiGT9E'
+const DISCORD_BUG_BOT_NAME     = 'TUI Bug Report'
+const DISCORD_BUG_EMBED_COLOR  = 0xFF5733  // Rouge (RGB: 255, 87, 51)
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * 📖 parseTelemetryEnv: Convert env var strings into booleans.
+ * 📖 Returns true/false when value is recognized, otherwise null.
+ * @param {unknown} value
+ * @returns {boolean|null}
+ */
+export function parseTelemetryEnv(value) {
+  if (typeof value !== 'string') return null
+  const normalized = value.trim().toLowerCase()
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true
+  if (['0', 'false', 'no', 'off'].includes(normalized)) return false
+  return null
+}
+
+/**
+ * 📖 Optional debug switch for telemetry troubleshooting (disabled by default).
+ * @returns {boolean}
+ */
+export function isTelemetryDebugEnabled() {
+  return parseTelemetryEnv(process.env.FREE_CODING_MODELS_TELEMETRY_DEBUG) === true
+}
+
+/**
+ * 📖 Writes telemetry debug traces to stderr only when explicitly enabled.
+ * @param {string} message
+ * @param {unknown} [meta]
+ */
+export function telemetryDebug(message, meta = null) {
+  if (!isTelemetryDebugEnabled()) return
+  const prefix = '[telemetry-debug]'
+  if (meta === null) {
+    process.stderr.write(`${prefix} ${message}\n`)
+    return
+  }
+  try {
+    process.stderr.write(`${prefix} ${message} ${JSON.stringify(meta)}\n`)
+  } catch {
+    process.stderr.write(`${prefix} ${message}\n`)
+  }
+}
+
+/**
+ * 📖 Ensure telemetry config shape exists even on old config files.
+ * @param {Record<string, unknown>} config
+ */
+export function ensureTelemetryConfig(config) {
+  if (!config.telemetry || typeof config.telemetry !== 'object') {
+    config.telemetry = { enabled: true, anonymousId: null }
+  }
+  // 📖 Only default enabled when unset; do not override a user's explicit opt-out
+  if (typeof config.telemetry.enabled !== 'boolean') {
+    config.telemetry.enabled = true
+  }
+  if (typeof config.telemetry.anonymousId !== 'string' || !config.telemetry.anonymousId.trim()) {
+    config.telemetry.anonymousId = null
+  }
+}
+
+/**
+ * 📖 Create or reuse a persistent anonymous distinct_id for PostHog.
+ * 📖 Stored locally in config so one user is stable over time without personal data.
+ * @param {Record<string, unknown>} config
+ * @returns {string}
+ */
+export function getTelemetryDistinctId(config) {
+  ensureTelemetryConfig(config)
+  if (config.telemetry.anonymousId) return config.telemetry.anonymousId
+
+  config.telemetry.anonymousId = `anon_${randomUUID()}`
+  saveConfig(config)
+  return config.telemetry.anonymousId
+}
+
+/**
+ * 📖 Convert Node platform to human-readable system name for analytics segmentation.
+ * @returns {string}
+ */
+export function getTelemetrySystem() {
+  if (process.platform === 'darwin') return 'macOS'
+  if (process.platform === 'win32') return 'Windows'
+  if (process.platform === 'linux') return 'Linux'
+  return process.platform
+}
+
+/**
+ * 📖 Infer terminal family from environment hints for coarse usage segmentation.
+ * 📖 Never sends full env dumps; only a normalized terminal label is emitted.
+ * @returns {string}
+ */
+export function getTelemetryTerminal() {
+  const termProgramRaw = (process.env.TERM_PROGRAM || '').trim()
+  const termProgram = termProgramRaw.toLowerCase()
+  const term = (process.env.TERM || '').toLowerCase()
+
+  if (termProgram === 'apple_terminal') return 'Terminal.app'
+  if (termProgram === 'iterm.app') return 'iTerm2'
+  if (termProgram === 'warpterminal' || process.env.WARP_IS_LOCAL_SHELL_SESSION) return 'Warp'
+  if (process.env.WT_SESSION) return 'Windows Terminal'
+  if (process.env.KITTY_WINDOW_ID || term.includes('kitty')) return 'kitty'
+  if (process.env.GHOSTTY_RESOURCES_DIR || term.includes('ghostty')) return 'Ghostty'
+  if (process.env.WEZTERM_PANE || termProgram === 'wezterm') return 'WezTerm'
+  if (process.env.KONSOLE_VERSION || termProgram === 'konsole') return 'Konsole'
+  if (process.env.GNOME_TERMINAL_SCREEN || termProgram === 'gnome-terminal') return 'GNOME Terminal'
+  if (process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm') return 'JetBrains Terminal'
+  if (process.env.TABBY_CONFIG_DIRECTORY || termProgram === 'tabby') return 'Tabby'
+  if (termProgram === 'vscode' || process.env.VSCODE_GIT_IPC_HANDLE) return 'VS Code Terminal'
+  if (process.env.ALACRITTY_SOCKET || term.includes('alacritty') || termProgram === 'alacritty') return 'Alacritty'
+  if (term.includes('foot') || termProgram === 'foot') return 'foot'
+  if (termProgram === 'hyper' || process.env.HYPER) return 'Hyper'
+  if (process.env.TMUX) return 'tmux'
+  if (process.env.STY) return 'screen'
+  // 📖 Generic fallback for many terminals exposing TERM_PROGRAM (e.g., Rio, Contour, etc.).
+  if (termProgramRaw) return termProgramRaw
+  if (term) return term
+
+  return 'unknown'
+}
+
+/**
+ * 📖 Resolve telemetry effective state with clear precedence:
+ * 📖 CLI flag > env var > enabled by default (forced for all users).
+ * @param {Record<string, unknown>} config
+ * @param {{ noTelemetry?: boolean }} cliArgs
+ * @returns {boolean}
+ */
+export function isTelemetryEnabled(config, cliArgs) {
+  if (cliArgs.noTelemetry) return false
+  const envTelemetry = parseTelemetryEnv(process.env.FREE_CODING_MODELS_TELEMETRY)
+  if (envTelemetry !== null) return envTelemetry
+  ensureTelemetryConfig(config)
+  return true
+}
+
+/**
+ * 📖 Fire-and-forget analytics ping: never blocks UX, never throws.
+ * @param {Record<string, unknown>} config
+ * @param {{ noTelemetry?: boolean }} cliArgs
+ * @param {{ event?: string, version?: string, mode?: string, ts?: string }} payload
+ */
+export async function sendUsageTelemetry(config, cliArgs, payload) {
+  if (!isTelemetryEnabled(config, cliArgs)) {
+    telemetryDebug('skip: telemetry disabled', {
+      cliNoTelemetry: cliArgs.noTelemetry === true,
+      envTelemetry: process.env.FREE_CODING_MODELS_TELEMETRY || null,
+      configEnabled: config?.telemetry?.enabled ?? null,
+    })
+    return
+  }
+
+  const apiKey = (
+    process.env.FREE_CODING_MODELS_POSTHOG_KEY ||
+    process.env.POSTHOG_PROJECT_API_KEY ||
+    POSTHOG_PROJECT_KEY_DEFAULT ||
+    ''
+  ).trim()
+  if (!apiKey) {
+    telemetryDebug('skip: missing api key')
+    return
+  }
+
+  const host = (
+    process.env.FREE_CODING_MODELS_POSTHOG_HOST ||
+    process.env.POSTHOG_HOST ||
+    POSTHOG_HOST_DEFAULT ||
+    POSTHOG_DEFAULT_HOST
+  ).trim().replace(/\/+$/, '')
+  if (!host) {
+    telemetryDebug('skip: missing host')
+    return
+  }
+
+  try {
+    const endpoint = `${host}${POSTHOG_CAPTURE_PATH}`
+    const distinctId = getTelemetryDistinctId(config)
+    const timestamp = typeof payload?.ts === 'string' ? payload.ts : new Date().toISOString()
+    const signal = (typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function')
+      ? AbortSignal.timeout(TELEMETRY_TIMEOUT)
+      : undefined
+
+    const posthogBody = {
+      api_key: apiKey,
+      event: payload?.event || 'app_start',
+      distinct_id: distinctId,
+      timestamp,
+      properties: {
+        $process_person_profile: false,
+        source: 'cli',
+        app: 'free-coding-models',
+        version: payload?.version || LOCAL_VERSION,
+        app_version: payload?.version || LOCAL_VERSION,
+        mode: payload?.mode || 'opencode',
+        system: getTelemetrySystem(),
+        terminal: getTelemetryTerminal(),
+      },
+    }
+
+    await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(posthogBody),
+      signal,
+    })
+    telemetryDebug('sent', {
+      event: posthogBody.event,
+      endpoint,
+      mode: posthogBody.properties.mode,
+      system: posthogBody.properties.system,
+      terminal: posthogBody.properties.terminal,
+    })
+  } catch {
+    // 📖 Ignore failures silently: analytics must never break the CLI.
+    telemetryDebug('error: send failed')
+  }
+}
+
+/**
+ * 📖 sendFeatureRequest: Send anonymous feature request to Discord via webhook.
+ * 📖 Called when user presses J key, types message, and presses Enter.
+ * 📖 Returns success/error status for UI feedback.
+ * @param {string} message
+ * @returns {Promise<{ success: boolean, error: string|null }>}
+ */
+export async function sendFeatureRequest(message) {
+  try {
+    // 📖 Collect anonymous telemetry for context (no personal data)
+    const system = getTelemetrySystem()
+    const terminal = getTelemetryTerminal()
+    const nodeVersion = process.version
+    const arch = process.arch
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'Unknown'
+
+    // 📖 Build Discord embed with rich metadata in footer (compact format)
+    const embed = {
+      description: message,
+      color: DISCORD_EMBED_COLOR,
+      timestamp: new Date().toISOString(),
+      footer: {
+        text: `v${LOCAL_VERSION} • ${system} • ${terminal} • ${nodeVersion} • ${arch} • ${timezone}`
+      }
+    }
+
+    const response = await fetch(DISCORD_WEBHOOK_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        username: DISCORD_BOT_NAME,
+        embeds: [embed]
+      }),
+      signal: AbortSignal.timeout(10000) // 📖 10s timeout for webhook
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`)
+    }
+
+    return { success: true, error: null }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error'
+    return { success: false, error: message }
+  }
+}
+
+/**
+ * 📖 sendBugReport: Send anonymous bug report to Discord via webhook.
+ * 📖 Called when user presses I key, types message, and presses Enter.
+ * 📖 Returns success/error status for UI feedback.
+ * @param {string} message
+ * @returns {Promise<{ success: boolean, error: string|null }>}
+ */
+export async function sendBugReport(message) {
+  try {
+    // 📖 Collect anonymous telemetry for context (no personal data)
+    const system = getTelemetrySystem()
+    const terminal = getTelemetryTerminal()
+    const nodeVersion = process.version
+    const arch = process.arch
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'Unknown'
+
+    // 📖 Build Discord embed with rich metadata in footer (compact format)
+    const embed = {
+      description: message,
+      color: DISCORD_BUG_EMBED_COLOR,
+      timestamp: new Date().toISOString(),
+      footer: {
+        text: `v${LOCAL_VERSION} • ${system} • ${terminal} • ${nodeVersion} • ${arch} • ${timezone}`
+      }
+    }
+
+    const response = await fetch(DISCORD_BUG_WEBHOOK_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        username: DISCORD_BUG_BOT_NAME,
+        embeds: [embed]
+      }),
+      signal: AbortSignal.timeout(10000) // 📖 10s timeout for webhook
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`)
+    }
+
+    return { success: true, error: null }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error'
+    return { success: false, error: message }
+  }
+}