#!/usr/bin/env bun
/**
 * CmdCode V0.5 - CLI 入口
 * 
 * 用法：
 *   cmdcode                        # 交互REPL模式
 *   cmdcode -p "提示词"            # 单次执行模式
 *   cmdcode -p "提示" --continue   # 继续上次会话
 *   cmdcode --sessions             # 列出所有会话
 *   cmdcode -h                     # 帮助
 */
import { parseArgs } from 'node:util'
import * as readline from 'node:readline'
import { t, initI18n } from './i18n.js'
import { createChatEngine, createChatEngineFromHistory, setGlobalPAVREnabled, isGlobalPAVREnabled } from './chat-factory.js'
import { loadConfig, updateAppConfig } from './config.js'
import { saveSession, loadSession, getLatestSessionId, listSessions } from './session.js'
import { BUILTIN_PROVIDERS, testConnection, type ModelProvider, type CustomModelConfig } from './models.js'
import { 
  // 密钥池管理
  loadChatKeyPool, addChatKey, removeChatKey,
  loadEmbeddingKeyPool, addEmbeddingKey, removeEmbeddingKey,
  // 简化接口
  saveKeys
} from './apikeys.js'
import {
  register, login, validateToken, loadUserCache, clearUserCache,
  restoreWorkspaceSnapshot,
} from './user.js'
import {
  createUserModel, loadUserModel, updateUserModel, deleteUserModel,
  listUserModels, getUserDefaultModel, setUserDefaultModel,
  testUserModelConnection, countUserModels, type UserModelConfig
} from './user-models.js'
import { setUserWorkspace, setUsername } from './tools.js'
import { printHelp } from './commands/help.js'
import { interactiveModelSetup } from './commands/model.js'
import { countHistoryMessages, getDirSize, printBanner, restoreWorkspaceFromSnapshot } from './commands/workspace.js'
import { userAuthFlow } from './commands/auth.js'
import { replLoop } from './commands/repl.js'
import { existsSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs'
import { isUsingFallbackKey } from './crypto-util.js'
// 向量记忆系统
import {
  initMemorySystem
} from './memory/memoryManager.js'
import { join } from 'node:path'
import { homedir } from 'node:os'
import { getSystemPrompt } from './chat.js'
import { SYSTEM_PROMPT_TEMPLATE } from './system-prompt.js'

const VERSION = '0.5.0'
const API_BASE = 'https://cmdcode.cn/xiaoc/cmdcode_api.php'

// ═══════════════════════════════════════════════════
// ANSI 样式工具
// ═══════════════════════════════════════════════════
const C = {
  reset: '\x1b[0m',
  bold: '\x1b[1m',
  dim: '\x1b[2m',
  italic: '\x1b[3m',
  // 前景色
  black: '\x1b[30m',
  red: '\x1b[31m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  magenta: '\x1b[35m',
  cyan: '\x1b[36m',
  white: '\x1b[37m',
  // 亮色
  brightBlack: '\x1b[90m',
  brightRed: '\x1b[91m',
  brightGreen: '\x1b[92m',
  brightYellow: '\x1b[93m',
  brightBlue: '\x1b[94m',
  brightMagenta: '\x1b[95m',
  brightCyan: '\x1b[96m',
  brightWhite: '\x1b[97m',
  // 背景色
  bgBlack: '\x1b[40m',
  bgRed: '\x1b[41m',
  bgGreen: '\x1b[42m',
  bgYellow: '\x1b[43m',
  bgBlue: '\x1b[44m',
  bgMagenta: '\x1b[45m',
  bgCyan: '\x1b[46m',
  bgWhite: '\x1b[47m',
}

// 检测终端是否支持颜色
const supportsColor = process.stdout.isTTY && (process.env.TERM !== 'dumb')
const color = supportsColor ? C : Object.fromEntries(Object.keys(C).map(k => [k, ''])) as typeof C

/** 品牌主题色 - Claude Code 经典橘黄风格（受 supportsColor 控制） */
const BRAND = supportsColor ? '\x1b[38;5;208m' : ''    // CmdCode品牌色 - 标准橘黄
const BRAND_DIM = supportsColor ? '\x1b[38;5;214m' : '' // 亮橘色
const ACCENT = supportsColor ? '\x1b[38;5;220m' : ''    // 强调色 - 金黄
const MUTED = supportsColor ? '\x1b[38;5;240m' : ''     // 次要信息 - 深灰
const SUCCESS = color.brightGreen // 成功
const ERROR = color.brightRed     // 错误
const WARN = color.brightYellow   // 警告

// ═══════════════════════════════════════════════════
// 显示函数
// ═══════════════════════════════════════════════════


/** 计算目录大小（字节） */
// ═══════════════════════════════════════════════════ - 会话级存储（ttyd 无 X 显示环境） */
let sessionClipboard = ''
// 安全：移至用户专属目录，避免多用户共享/tmp导致泄露
const CLIPBOARD_FILE = join(homedir(), '.cmdcode', 'clipboard')
// 确保剪贴板文件权限为600（仅用户可读写）
function ensureClipboardSecure(): void {
  try { chmodSync(CLIPBOARD_FILE, 0o600) } catch { /* ignore */ }
}
// ═══════════════════════════════════════════════════
// 安全密钥库管理
// ═══════════════════════════════════════════════════

/** 安全密码输入（隐藏输入） */
async function askPassword(prompt: string): Promise<string> {
  return new Promise((resolve) => {
    process.stdout.write(prompt)
    process.stdin.setRawMode(true)
    let password = ''
    process.stdin.on('data', (data: Buffer) => {
      const char = data.toString('utf8')
      if (char === '\n' || char === '\r' || char === '\u0004') {
        process.stdin.setRawMode(false)
        console.log('') // 换行
        resolve(password)
      } else if (char === '\u0003') {
        process.stdin.setRawMode(false)
        resolve('')
      } else {
        password += char
        process.stdout.write('*')
      }
    })
  })
}

async function copyToClipboard(text: string): Promise<boolean> {
  try {
    sessionClipboard = text
    const { writeFileSync } = require('node:fs')
    writeFileSync(CLIPBOARD_FILE, text, 'utf-8')
    return true
  } catch {
    return false
  }
}

async function pasteFromClipboard(): Promise<string> {
  try {
    // 优先使用会话剪贴板
    if (sessionClipboard) {
      return sessionClipboard
    }
    // 尝试读取文件
    const { existsSync, readFileSync } = require('node:fs')
    if (existsSync(CLIPBOARD_FILE)) {
      return readFileSync(CLIPBOARD_FILE, 'utf-8')
    }
    return ''
  } catch {
    return ''
  }
}

/** REPL 输入 - 使用标准 readline（Bun 兼容） */
function askREPL(prompt: string): Promise<{ input: string; action: 'submit' | 'exit' }> {
  return new Promise((resolve) => {
    const stdin = process.stdin
    const stdout = process.stdout
    const wasRaw = stdin.isRaw

    // 进入 raw 模式，关闭行缓冲
    if (typeof stdin.setRawMode === 'function') {
      stdin.setRawMode(true)
    }
    readline.emitKeypressEvents(stdin)

    let buffer = ''
    let cursorPos = 0

    const render = () => {
      // 清除行并重绘
      stdout.write('\r\x1b[K')
      stdout.write(prompt + ' ' + buffer)
      // 移动光标到正确位置
      if (cursorPos < buffer.length) {
        stdout.write(`\x1b[${buffer.length - cursorPos}D`)
      }
    }

    render()

    // Issue 7: SIGWINCH - terminal resize auto-redraw
    const onResize = () => render()
    process.stdout.on('resize', onResize)

    const cleanup = () => {
      if (typeof stdin.setRawMode === 'function') {
        stdin.setRawMode(wasRaw ?? false)
      }
      stdin.removeListener('keypress', onKeypress)
      process.stdout.removeListener('resize', onResize)
      stdout.write('\n')
    }

    const onKeypress = async (str: string, key: any) => {
      // Ctrl+E (0x05) 退出
      if (key.ctrl && key.name === 'e') {
        cleanup()
        resolve({ input: '', action: 'exit' })
        return
      }

      // Ctrl+L 清屏
      if (key.ctrl && key.name === 'l') {
        stdout.write('\x1b[2J\x1b[H')
        render()
        return
      }

      // Ctrl+C (0x03) 复制
      if (key.ctrl && key.name === 'c') {
        if (buffer.length > 0) {
          await copyToClipboard(buffer)
          // 显示提示后自动清除（不遮挡输入行）
          stdout.write(`\r\x1b[K${SUCCESS}✓ ${t("clip.copied")}${color.reset}`)
          setTimeout(() => {
            stdout.write('\r\x1b[K')
            render()
          }, 1000)
        }
        return
      }

      // Ctrl+X (0x18) 剪切
      if (key.ctrl && key.name === 'x') {
        if (buffer.length > 0) {
          await copyToClipboard(buffer)
          buffer = ''
          cursorPos = 0
          stdout.write(`\r\x1b[K${SUCCESS}✓ ${t("clip.cut")}${color.reset}`)
          setTimeout(() => {
            stdout.write('\r\x1b[K')
            render()
          }, 1000)
        }
        return
      }

      // Ctrl+V (0x16) 粘贴
      if (key.ctrl && key.name === 'v') {
        const pasted = await pasteFromClipboard()
        if (pasted) {
          const cleanPasted = pasted.replace(/[\r\n]+/g, ' ')
          const before = buffer.slice(0, cursorPos)
          const after = buffer.slice(cursorPos)
          buffer = before + cleanPasted + after
          cursorPos += cleanPasted.length
          render()
        }
        return
      }

      // Enter 提交
      if (key.name === 'return' || key.name === 'enter') {
        cleanup()
        // 截断超长输入，防止误粘贴长文超出上下文
        const limited = buffer.length > 8000 ? buffer.slice(0, 8000) : buffer
        resolve({ input: limited.trim(), action: 'submit' })
        return
      }

      // Backspace / Delete
      if (key.name === 'backspace') {
        if (cursorPos > 0) {
          const before = buffer.slice(0, cursorPos - 1)
          const after = buffer.slice(cursorPos)
          buffer = before + after
          cursorPos--
          render()
        }
        return
      }
      if (key.name === 'delete') {
        if (cursorPos < buffer.length) {
          const before = buffer.slice(0, cursorPos)
          const after = buffer.slice(cursorPos + 1)
          buffer = before + after
          render()
        }
        return
      }

      // 左右箭头
      if (key.name === 'left') {
        if (cursorPos > 0) {
          cursorPos--
          render()
        }
        return
      }
      if (key.name === 'right') {
        if (cursorPos < buffer.length) {
          cursorPos++
          render()
        }
        return
      }

      // Home / End
      if (key.name === 'home') {
        cursorPos = 0
        render()
        return
      }
      if (key.name === 'end') {
        cursorPos = buffer.length
        render()
        return
      }

      // 普通字符
      if (str && str.length === 1 && !key.ctrl && !key.meta) {
        const before = buffer.slice(0, cursorPos)
        const after = buffer.slice(cursorPos)
        buffer = before + str + after
        cursorPos++
        render()
      }
    }

    stdin.on('keypress', onKeypress)
  })
}

/** readline 单行输入工具 */
function askQuestion(query: string): Promise<string> {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  })
  return new Promise((resolve) => {
    rl.question(query, (answer) => {
      rl.close()
      resolve(answer.trim())
    })
  })
}

/** 密码输入（隐藏） */
function askPassword(query: string): Promise<string> {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  })
  return new Promise((resolve) => {
    if (process.stdout.isTTY) {
      const stdin = process.stdin
      const wasRaw = stdin.isRaw
      if (wasRaw !== undefined) stdin.setRawMode?.(true)
      
      process.stdout.write(query)
      let password = ''
      
      const onData = (char: Buffer) => {
        const c = char.toString()
        if (c === '\n' || c === '\r') {
          if (wasRaw !== undefined) stdin.setRawMode?.(wasRaw)
          stdin.removeListener('data', onData)
          rl.close()
          process.stdout.write('\n')
          resolve(password)
        } else if (c === '\u007F' || c === '\b') {
          if (password.length > 0) {
            password = password.slice(0, -1)
            process.stdout.write('\b \b')
          }
        } else if (c === '\u0003') {
          // Ctrl+C - 取消密码输入，返回空字符串
          if (wasRaw !== undefined) stdin.setRawMode?.(wasRaw)
          stdin.removeListener('data', onData)
          rl.close()
          process.stdout.write('\n')
          resolve('')
        } else {
          password += c
          process.stdout.write('*')
        }
      }
      stdin.on('data', onData)
    } else {
      rl.question(query, (answer) => {
        rl.close()
        resolve(answer.trim())
      })
    }
  })
}

// ═══════════════════════════════════════════════════
// 用户登录/注册交互流程 → 已提取至 commands/auth.ts
// ═══════════════════════════════════════════════════



// ═══════════════════════════════════════════════════
// 工作区快照（断点续传）
// ═══════════════════════════════════════════════════

// ═══════════════════════════════════════════════════
// 主流程
// ═══════════════════════════════════════════════════

async function main() {
  // 初始化国际化系统（必须在任何输出之前）
  initI18n()
  
  // P4 #2.10: 确保剪贴板文件权限安全
  ensureClipboardSecure()
  
  // ═══════════════════════════════════════════════
  // 信号处理器 - 确保退出时保存工作区
  // ═══════════════════════════════════════════════
  let onExit: (() => Promise<void>) | null = null
  let isExiting = false
  
  const handleSignal = async (signal: string) => {
    if (isExiting) return
    isExiting = true
    console.log(`\n  ${MUTED}${t('signal.received', { signal })}${color.reset}`)
    if (onExit) {
      await onExit()
    }
    process.exit(0)
  }
  
  process.on('SIGINT', () => handleSignal('SIGINT'))
  process.on('SIGTERM', () => handleSignal('SIGTERM'))
  process.on('SIGHUP', () => handleSignal('SIGHUP'))
  
  const { values } = parseArgs({
    options: {
      prompt: { type: 'string', short: 'p' },
      continue: { type: 'boolean', short: 'c' },
      sessions: { type: 'boolean', short: 's' },
      model: { type: 'string', short: 'm' },
      version: { type: 'boolean', short: 'v' },
      help: { type: 'boolean', short: 'h' },
      pavr: { type: 'boolean', short: 'P', default: true },      // 启用 PAVR 循环
      'no-pavr': { type: 'boolean', short: 'N', default: false }, // 禁用 PAVR 循环
    },
    strict: false,
  })

  // 设置 PAVR 模式
  if (values['no-pavr']) {
    setGlobalPAVREnabled(false)
  } else if (values.pavr) {
    setGlobalPAVREnabled(true)
  }

  if (values.help) { printHelp(VERSION, color, BRAND, MUTED, ACCENT, SUCCESS, ERROR, WARN); return }
  if (values.version) { console.log(`CmdCode V${VERSION}`); return }

  // 🔧 管道输入检测：stdin 不是 TTY 时，读取全部内容作为 -p 模式输入
  if (!process.stdin.isTTY && !values.prompt) {
    const pipedInput = await new Promise<string>((resolve) => {
      let data = ''
      process.stdin.setEncoding('utf-8')
      process.stdin.on('data', (chunk: string) => { data += chunk })
      process.stdin.on('end', () => resolve(data.trim()))
      // 超时保护：5秒内没读完就先提交
      setTimeout(() => resolve(data.trim()), 5000)
    })
    if (pipedInput.length > 0) {
      values.prompt = pipedInput
    }
  }

  let config = loadConfig()
  if (values.model) config.model = values.model as string

  // ═══════════════════════════════════════════════
  // 核心改进1：用户登录/注册
  // ═══════════════════════════════════════════════
  const userInfo = await userAuthFlow(VERSION, color, BRAND, ACCENT, MUTED, SUCCESS, ERROR, WARN, askQuestion, askPassword)

  // 设置用户专属工作区到沙箱系统
  setUserWorkspace(userInfo.workspaceDir)
  setUsername(userInfo.username)

  // ═══════════════════════════════════════════════
  // 初始化向量记忆系统
  // ═══════════════════════════════════════════════
  try {
    initMemorySystem()
    // 注：密钥库状态检查已移至各功能模块内部按需执行
  } catch (e) {
    console.log(`  ${MUTED}${t('model.memory_init_failed')}${color.reset}`)
  }

  // ═══════════════════════════════════════════════
  // 核心改进2：断点续传 - 恢复上次工作区
  // ═══════════════════════════════════════════════
  let restoredMessages: Message[] | undefined
  
  if (!values.prompt) {
    process.stdout.write(`  ${MUTED}${t("session.checking_snapshot")}${color.reset}`)
    try {
      const snapshot = await restoreWorkspaceSnapshot(userInfo)
      process.stdout.write('\r' + ' '.repeat(30) + '\r')
      if (snapshot) {
        const msgs = restoreWorkspaceFromSnapshot(snapshot, userInfo, { WARN, color })
        if (msgs && msgs.length > 0) {
          restoredMessages = msgs
          // 不再显示恢复信息，在 printBanner 统一展示
        }
      } else {
        // 没有快照，静默跳过
      }
    } catch {
      process.stdout.write('\r' + ' '.repeat(30) + '\r')
      console.log(`  ${MUTED}${t('model.snapshot_check_failed')}${color.reset}`)
    }
  }

  // ═══════════════════════════════════════════════
  // 核心改进3：模型配置（用户自定义 > 系统默认）
  // ═══════════════════════════════════════════════
  
  // 先检查用户是否有自定义模型配置
  const userDefaultModel = getUserDefaultModel(userInfo.username)
  let modelOnline = false
  let modelLatencyMs: number | undefined
  
  if (userDefaultModel) {
    // 使用用户自定义模型
    config = {
      apiKey: userDefaultModel.apiKey,
      baseUrl: userDefaultModel.baseUrl,
      model: userDefaultModel.model,
      timeoutMs: config.timeoutMs,
    }
    
    process.stdout.write(`  ${ACCENT}${t("model.connecting")} ${userDefaultModel.name} ...${color.reset}`)
    const testResult = await testConnection(config.baseUrl, config.apiKey, config.model)
    process.stdout.write('\r' + ' '.repeat(40) + '\r')
    
    if (testResult.success) {
      modelOnline = true
      modelLatencyMs = testResult.latencyMs
    } else {
      console.log(`  ${WARN}${t("model.test_failed")} ${testResult.error}${color.reset}`)
      console.log(`  ${MUTED}${t('model.manage_hint')}${color.reset}`)
    }
  } else if (!config.apiKey) {
    // 系统默认配置也没有，交互式配置
    const setup = await interactiveModelSetup(userInfo.username, color, BRAND, MUTED, SUCCESS, ERROR, WARN, ACCENT, askQuestion)
    if (!setup) {
      console.log('')
      console.log(`  ${ACCENT}${t('model.no_config_exit')}${color.reset}`)
      process.exit(0)
    }
    
    // 如果是用户自定义配置，存储到用户目录
    if (setup.saveToUser) {
      createUserModel(userInfo.username, {
        name: setup.name || setup.model,
        model: setup.model,
        baseUrl: setup.baseUrl,
        apiKey: setup.apiKey,
        note1: setup.note1,
        note2: setup.note2,
      })
      console.log(`  ${SUCCESS}${t('model.saved')}${color.reset}`)
    } else {
      // 保存为系统默认
      saveKeys(setup.apiKey, setup.baseUrl)
      updateAppConfig({ model: setup.model })
    }
    
    config = {
      apiKey: setup.apiKey,
      baseUrl: setup.baseUrl,
      model: setup.model,
      timeoutMs: config.timeoutMs,
    }

    console.log('')
    console.log(`  ${ACCENT}${t('model.encrypted_saved')}${color.reset}`)
    console.log('')
  } else {
    // 使用系统默认配置
    process.stdout.write(`  ${ACCENT}${t("model.connecting")} ${config.model} ...${color.reset}`)
    const testResult = await testConnection(config.baseUrl, config.apiKey, config.model)
    process.stdout.write('\r' + ' '.repeat(40) + '\r')
    if (testResult.success) {
      modelOnline = true
      modelLatencyMs = testResult.latencyMs
    } else {
      console.log(`  ${WARN}${t("model.test_failed")} ${testResult.error}${color.reset}`)
      console.log(`  ${MUTED}${t('model.possible_reasons')}${color.reset}`)
      console.log(`  ${MUTED}${t('model.manage_hint2')}${color.reset}`)
      console.log('')
    }
  }

  // 列出会话
  if (values.sessions) {
    const sessions = listSessions()
    if (sessions.length === 0) {
      console.log(`  ${MUTED}暂无会话记录${color.reset}`)
    } else {
      console.log('')
      console.log(`  ${color.bold}${t('session.list_title')}${color.reset}`)
      console.log(`  ${MUTED}────────────────────────────────────────────${color.reset}`)
      for (const s of sessions) {
        console.log(`    ${BRAND}${s.id}${color.reset}`)
        console.log(`    ${MUTED}${t('session.messages')}: ${s.messageCount} · ${t('session.updated')}: ${s.updatedAt.slice(0, 19)}${color.reset}`)
        if (s.preview) console.log(`    ${MUTED}${t('session.preview')}: ${s.preview}${color.reset}`)
        console.log('')
      }
    }
    return
  }

  // 单次执行模式
  if (values.prompt) {
    const prompt = values.prompt as string
    let messages: Message[] | undefined

    if (values.continue) {
      const sessionId = getLatestSessionId()
      if (sessionId) {
        messages = loadSession(sessionId) || undefined
        if (messages) {
          console.log(`  ${MUTED}${t('session.restored')} ${sessionId} (${messages.length} ${t('session.messages_count')})${color.reset}`)
        }
      } else {
        console.log(`  ${MUTED}${t('session.no_restore')}${color.reset}`)
      }
    }

    // 支持 CMD_WORKSPACE 环境变量覆盖工作目录
    const cmdWorkspace = process.env.CMD_WORKSPACE
    // Issue 10: Warn about potential path conflict
    if (values.continue && cmdWorkspace) {
      console.log(`  ${WARN}⚠️ --continue + CMD_WORKSPACE: workspace changed, session files may be at original path${color.reset}`)
    }
    // 🚀 使用工厂函数创建引擎（支持 PAVR 循环）
    const engine = messages
      ? createChatEngineFromHistory(messages, undefined, config, cmdWorkspace)
      : createChatEngine(undefined, config, undefined, cmdWorkspace)

    // 如果设置了 CMD_WORKSPACE，切换到该目录
    if (cmdWorkspace) {
      process.chdir(cmdWorkspace)
      setUserWorkspace(cmdWorkspace)
    }

    try {
      const finalText = await engine.chat(prompt)
      const sessionId = saveSession(engine.getHistory())
      console.log(`\n  ${MUTED}${t('session.saved')} ${sessionId}${color.reset}`)
      
      // 【自动修复】解析大模型输出，提取代码块并保存为文件（若大模型未调用 file_write）
      const codeBlockRegex = /```(\w+)?\s*\n([\s\S]*?)```/g
      let match
      let fileSaved = false
      while ((match = codeBlockRegex.exec(finalText)) !== null) {
        const lang = match[1] || 'txt'
        const code = match[2].trim()
        if (code.length > 0) {
          const ext = lang === 'python' ? 'py' : lang === 'javascript' ? 'js' : lang === 'typescript' ? 'ts' : lang
          const fileName = `solution.${ext}`
          try {
            writeFileSync(fileName, code, 'utf-8')
            console.log(`  ✅ Auto-saved code to ${fileName}`)
            fileSaved = true
          } catch (e: any) {
            console.error(`  ❌ Failed to save ${fileName}: ${e.message}`)
          }
        }
      }
      if (!fileSaved) {
        console.warn(`  ⚠️ No code block found in output.`)
      }
      
      process.exit(0)
    } catch (e: any) {
      if (e.status === 429) {
        console.error(`\n  ${WARN}${t("error.429_single")}${color.reset}`)
        console.error(`  ${MUTED}${t("error.switch_model_hint")}${color.reset}`)
      } else if (e.code === 'ECONNREFUSED' || e.code === 'ENOTFOUND' || e.code === 'ETIMEDOUT') {
        console.error(`\n  ${ERROR}${t("error.network_single")} ${e.message}${color.reset}`)
        console.error(`  ${MUTED}${t("error.check_network_hint")}${color.reset}`)
      } else {
        console.error(`\n  ${ERROR}${t("error.general_single")} ${e.message}${color.reset}`)
        console.error(`  ${MUTED}${t("error.model_hint_single")}${color.reset}`)
      }
      process.exit(1)
    }
    return
  }

  // 交互REPL模式
  // 获取模型显示名称
  const modelName = userDefaultModel?.name || config.model
  
  // 计算存储空间和对话历史
  const usedBytes = getDirSize(userInfo.workspaceDir)
  const historyCount = restoredMessages?.length || countHistoryMessages(userInfo.workspaceDir)
  
  printBanner(userInfo, { name: modelName, model: config.model, online: modelOnline, latencyMs: modelLatencyMs }, historyCount, usedBytes, { BRAND, ACCENT, MUTED, SUCCESS, WARN, color })

  // 显示 PAVR 状态
  console.log(`  ${isGlobalPAVREnabled() ? ACCENT : MUTED}🚀 PAVR: ${isGlobalPAVREnabled() ? '启用' : '禁用'}${color.reset}`)

  // 设置工作区为用户专属目录
  process.chdir(userInfo.workspaceDir)

  // 🚀 使用工厂函数创建引擎（支持 PAVR 循环）
  const engine = restoredMessages
    ? createChatEngineFromHistory(restoredMessages, undefined, config, userInfo.workspaceDir)
    : createChatEngine(undefined, config, undefined, userInfo.workspaceDir)

  // 默认系统提示词（用户自定义 > 默认模板，统一从 secrets.enc 读取）
  const customPrompt = getSystemPrompt()
  const DEFAULT_SYSTEM_PROMPT = customPrompt || SYSTEM_PROMPT_TEMPLATE + `

Current user workspace: ${process.cwd()}`

  // → REPL 主循环已提取至 commands/repl.ts
  await replLoop({
    userInfo,
    engine,
    config,
    modelOnline,
    modelLatencyMs,
    userDefaultModel,
    defaultSystemPrompt: DEFAULT_SYSTEM_PROMPT,
    color,
    BRAND,
    ACCENT,
    MUTED,
    SUCCESS,
    ERROR,
    WARN,
    askREPL,
    askQuestion,
    askPassword,
    registerExitHandler: (handler) => { onExit = handler },
  })
}

main().catch(e => {
  console.error('Fatal:', e.message)
  process.exit(1)
})