type Role = 'system' | 'user' | 'assistant'
 
type ChatMessage = {
  role: Role
  content: string
}
 
type ParsedAssistant = {
  action?: { tool: string; input: string }
  final?: string
}
 

type DeepSeekMessage = { content?: string }
type DeepSeekChoice = { message?: DeepSeekMessage }
type DeepSeekResponse = { choices?: DeepSeekChoice[] }
 
async function callLLMs(messages: ChatMessage[]): Promise<string> {
  const res = await fetch('https://api.deepseek.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.DEEPSEEK_API_KEY}`,
    },
    body: JSON.stringify({
      model: 'deepseek-chat',
      messages,
      temperature: 0.35,
    }),
  })
 
  if (!res.ok) {
    const text = await res.text()
    throw new Error(`API 错误: ${res.status} ${text}`)
  }
 
  const data = (await res.json()) as DeepSeekResponse
  const content = data.choices?.[0]?.message?.content
  if (typeof content !== 'string') {
    throw new Error('返回内容为空')
  }
  return content
}
 

async function callLLMs(messages: ChatMessage[]): Promise<string> {
  const res = await fetch('https://api.deepseek.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.DEEPSEEK_API_KEY}`,
    },
    body: JSON.stringify({
      model: 'deepseek-chat',
      messages,
      temperature: 0.35,
    }),
  })
 
  if (!res.ok) {
    const text = await res.text()
    throw new Error(`API 错误: ${res.status} ${text}`)
  }
 
  const data = (await res.json()) as DeepSeekResponse
  const content = data.choices?.[0]?.message?.content
  if (typeof content !== 'string') {
    throw new Error('返回内容为空')
  }
  return content
}
 
function parseAssistant(content: string): ParsedAssistant {
  const actionMatch = content.match(
    /<action[^>]*tool="([^"]+)"[^>]*>([\s\S]*?)<\/action>/i,
  )
  const finalMatch = content.match(/<final>([\s\S]*?)<\/final>/i)
 
  const parsed: ParsedAssistant = {}
  if (actionMatch) {
    parsed.action = {
      tool: actionMatch[1],
      input: actionMatch[2]?.trim() ?? '',
    }
  }
  if (finalMatch) {
    parsed.final = finalMatch[1]?.trim()
  }
 
  return parsed
}
 

async function callLLMs(messages: ChatMessage[]): Promise<string> {
  const res = await fetch('https://api.deepseek.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.DEEPSEEK_API_KEY}`,
    },
    body: JSON.stringify({
      model: 'deepseek-chat',
      messages,
      temperature: 0.35,
    }),
  })
 
  if (!res.ok) {
    const text = await res.text()
    throw new Error(`API 错误: ${res.status} ${text}`)
  }
 
  const data = (await res.json()) as DeepSeekResponse
  const content = data.choices?.[0]?.message?.content
  if (typeof content !== 'string') {
    throw new Error('返回内容为空')
  }
  return content
}
 
function parseAssistant(content: string): ParsedAssistant {
  const actionMatch = content.match(
    /<action[^>]*tool="([^"]+)"[^>]*>([\s\S]*?)<\/action>/i,
  )
  const finalMatch = content.match(/<final>([\s\S]*?)<\/final>/i)
 
  const parsed: ParsedAssistant = {}
  if (actionMatch) {
    parsed.action = {
      tool: actionMatch[1],
      input: actionMatch[2]?.trim() ?? '',
    }
  }
  if (finalMatch) {
    parsed.final = finalMatch[1]?.trim()
  }
 
  return parsed
}
 
async function AgentLoop(question: string) {
  const systemPrompt = await Bun.file('prompt.md').text()
 
  const history: ChatMessage[] = [
    { role: 'system', content: systemPrompt },
    { role: 'user', content: question },
  ]
 
  for (let step = 0; step < 10; step++) {
    const assistantText = await callLLMs(history)
    console.log(`\n[LLM 第 ${step + 1} 轮输出]\n${assistantText}\n`)
    history.push({ role: 'assistant', content: assistantText })
 
    const parsed = parseAssistant(assistantText)
 
    if (parsed.final) {
      return parsed.final
    }
 
    break // 工具调用暂时跳过
  }
 
  return '未能生成最终回答，请重试或调整问题。'
}
 

export type ToolName = 'getWeather' | 'getTime'
export type ToolFn = (input: string) => Promise<string>
 
type WeatherInput = { error: string } | { city: string; time: string }
 
function parseWeatherInput(input: string): WeatherInput {
  try {
    const parsed = JSON.parse(input)
    const city = parsed?.city
    const time = parsed?.time
 
    if (!city || typeof city !== 'string') {
      return { error: 'getWeather 需要 city 字符串' }
    }
 
    if (!time || typeof time !== 'string') {
      return { error: 'getWeather 需要 time 字符串' }
    }
 
    return { city: city.trim(), time: time.trim() }
  } catch {
    return {
      error:
        'getWeather 参数需为 JSON，如 {"city":"上海","time":"2026-02-27 10:00"}',
    }
  }
}
 
function buildMockWeather(city: string, time: string): string {
  const conditions = ['晴', '多云', '阴', '小雨', '阵雨']
  const winds = ['东北风 2 级', '东风 3 级', '西南风 2 级', '北风 1 级']
  const seed = Array.from(`${city}|${time}`).reduce(
    (acc, ch) => acc + ch.charCodeAt(0),
    0,
  )
  const condition = conditions[seed % conditions.length] ?? '晴'
  const wind = winds[seed % winds.length] ?? '微风 1 级'
  const temp = 12 + (seed % 20)
  const humidity = 35 + (seed % 55)
  return `天气信息：${city} 在 ${time} 的天气为${condition}，气温 ${temp}°C，${wind}，湿度 ${humidity}%。`
}
 
export const TOOLKIT: Record<ToolName, ToolFn> = {
  async getTime() {
    return new Date().toISOString()
  },
 
  async getWeather(rawInput: string) {
    const parsed = parseWeatherInput(rawInput.trim())
    if ('error' in parsed) return parsed.error
    return buildMockWeather(parsed.city, parsed.time)
  },
}
 

type Role = 'system' | 'user' | 'assistant'
 
type ChatMessage = {
  role: Role
  content: string
}
 
type ParsedAssistant = {
  action?: { tool: string; input: string }
  final?: string
}
 
type DeepSeekMessage = { content?: string }
type DeepSeekChoice = { message?: DeepSeekMessage }
type DeepSeekResponse = { choices?: DeepSeekChoice[] }
 
// 示例里省略 import，默认 TOOLKIT / ToolName 来自 tools.ts
type ToolName = 'getWeather' | 'getTime'
declare const TOOLKIT: Record<ToolName, (input: string) => Promise<string>>
 
async function callLLMs(messages: ChatMessage[]): Promise<string> {
  const res = await fetch('https://api.deepseek.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.DEEPSEEK_API_KEY}`,
    },
    body: JSON.stringify({
      model: 'deepseek-chat',
      messages,
      temperature: 0.35,
    }),
  })
 
  if (!res.ok) {
    const text = await res.text()
    throw new Error(`API 错误: ${res.status} ${text}`)
  }
 
  const data = (await res.json()) as DeepSeekResponse
  const content = data.choices?.[0]?.message?.content
  if (typeof content !== 'string') {
    throw new Error('返回内容为空')
  }
  return content
}
 
function parseAssistant(content: string): ParsedAssistant {
  const actionMatch = content.match(
    /<action[^>]*tool="([^"]+)"[^>]*>([\s\S]*?)<\/action>/i,
  )
  const finalMatch = content.match(/<final>([\s\S]*?)<\/final>/i)
 
  const parsed: ParsedAssistant = {}
  if (actionMatch) {
    parsed.action = {
      tool: actionMatch[1],
      input: actionMatch[2]?.trim() ?? '',
    }
  }
  if (finalMatch) {
    parsed.final = finalMatch[1]?.trim()
  }
 
  return parsed
}
 
async function AgentLoop(question: string) {
  const systemPrompt = await Bun.file('prompt.md').text()
 
  const history: ChatMessage[] = [
    { role: 'system', content: systemPrompt },
    { role: 'user', content: question },
  ]
 
  for (let step = 0; step < 10; step++) {
    const assistantText = await callLLMs(history)
    console.log(`\n[LLM 第 ${step + 1} 轮输出]\n${assistantText}\n`)
    history.push({ role: 'assistant', content: assistantText })
 
    const parsed = parseAssistant(assistantText)
 
    if (parsed.final) {
      return parsed.final
    }
 
    // 新增：模型触发 action 时，执行工具并回填 observation
    if (parsed.action) {
      const toolFn = TOOLKIT[parsed.action.tool as ToolName]
      let observation: string
 
      if (toolFn) {
        observation = await toolFn(parsed.action.input)
      } else {
        observation = `未知工具: ${parsed.action.tool}`
      }
 
      console.log(`<observation>${observation}</observation>\n`)
 
      history.push({
        role: 'user',
        content: `<observation>${observation}</observation>`,
      })
      continue
    }
 
    break
  }
 
  return '未能生成最终回答，请重试或调整问题。'
}
 
// 新增：CLI 入口
async function main() {
  const userQuestion = process.argv.slice(2).join(' ') || '上海现在天气如何？'
  console.log(`用户问题: ${userQuestion}`)
 
  try {
    const answer = await AgentLoop(userQuestion)
    console.log('\n=== 最终回答 ===')
    console.log(answer)
  } catch (err) {
    console.error(`运行失败: ${(err as Error).message}`)
  }
}
 
await main()
 

if (!process.env.QINIU_API_KEY) {
  throw new Error('缺少环境变量 QINIU_API_KEY，请参考 .env.example 配置')
}
 
// 示例省略 import：默认 createOpenAI 已可用
 
// 七牛大模型推理服务，兼容 OpenAI 协议
const qiniu = createOpenAI({
  apiKey: process.env.QINIU_API_KEY,
  baseURL: 'https://api.qnaigc.com/v1',
  // 兼容模式：不发送 OpenAI 专属字段，避免第三方接口报错
  compatibility: 'compatible',
})
 
const modelName = process.env.QINIU_MODEL ?? 'claude-4.6-sonnet'
 
export const model = qiniu(modelName)
 

// 示例省略 import：默认 tool/z/readFile/writeFile/editFile/bash/webFetch 已可用
export const TOOLS = {
  read_file: tool({
    description:
      '读取本地文件内容。大文件建议用 offset + limit 分段读取，避免一次性读取撑爆上下文。输出带行号，方便定位。',
    parameters: z.object({
      path: z.string().describe('文件路径（相对于当前工作目录）'),
      offset: z
        .number()
        .optional()
        .describe('从第几行开始读（0-indexed，默认从头）'),
      limit: z
        .number()
        .optional()
        .describe('最多读取多少行（默认读到文件末尾）'),
    }),
    execute: readFile,
  }),
 
  write_file: tool({
    description:
      '将内容写入文件。文件不存在则创建，已存在则完整覆盖。局部修改优先用 edit_file。',
    parameters: z.object({
      path: z.string().describe('文件路径（相对于当前工作目录）'),
      content: z.string().describe('要写入的完整文件内容'),
    }),
    execute: writeFile,
  }),
 
  edit_file: tool({
    description:
      '替换文件中的特定字符串。old_string 必须在文件中唯一存在（仅出现一次），否则会报错。建议先用 read_file 确认目标字符串。',
    parameters: z.object({
      path: z.string().describe('文件路径（相对于当前工作目录）'),
      old_string: z.string().describe('要被替换的原始字符串，必须唯一'),
      new_string: z.string().describe('替换后的新字符串'),
    }),
    execute: editFile,
  }),
 
  bash: tool({
    description:
      '执行 Shell 命令。危险命令（如 rm -rf）会暂停并等待用户确认。命令输出超长时自动截断。',
    parameters: z.object({
      command: z.string().describe('要执行的 Shell 命令'),
      timeout: z.number().optional().describe('超时时间（毫秒），默认 30000'),
    }),
    execute: bash,
  }),
 
  web_fetch: tool({
    description:
      '抓取网页内容并转换为 Markdown 格式返回。适合查阅文档、README、API 参考。',
    parameters: z.object({
      url: z.string().describe('要抓取的完整 URL（包含 https://）'),
    }),
    execute: webFetch,
  }),
}
 

interface Params {
  command: string
  timeout?: number
}
 
// 示例省略 import：默认 detectDanger / confirmFromUser / truncateOutput 已可用
export async function bash({
  command,
  timeout = 30_000,
}: Params): Promise<string> {
  // 危险命令检测：block 直接拒绝，confirm 等用户确认
  const danger = detectDanger(command)
 
  if (danger === 'block') {
    return `拒绝执行：该命令已被自动阻止（高风险操作）。\n命令：${command}`
  }
 
  if (danger === 'confirm') {
    const approved = await confirmFromUser(command)
    if (!approved) {
      return `用户拒绝执行命令：${command}`
    }
  }
 
  // 执行命令
  const controller = new AbortController()
  const timer = setTimeout(() => controller.abort(), timeout)
 
  let stdout = ''
  let stderr = ''
  let exitCode = 0
 
  try {
    const proc = Bun.spawn(['sh', '-c', command], {
      stdout: 'pipe',
      stderr: 'pipe',
    })
 
    controller.signal.addEventListener('abort', () => proc.kill())
    ;[stdout, stderr] = await Promise.all([
      new Response(proc.stdout).text(),
      new Response(proc.stderr).text(),
    ])
    exitCode = await proc.exited
  } catch (e) {
    return `执行失败：${(e as Error).message}`
  } finally {
    clearTimeout(timer)
  }
 
  // 整合输出
  const parts: string[] = []
  if (stdout) parts.push(stdout)
  if (stderr) parts.push(`[stderr]\n${stderr}`)
  if (exitCode !== 0) parts.push(`[exit code: ${exitCode}]`)
 
  const output = parts.join('\n').trim() || '(无输出)'
 
  return truncateOutput('bash', output)
}
 

export type DangerLevel = 'safe' | 'confirm' | 'block'
 
// 示例省略 import：这里用一个占位函数表示 path.resolve(cwd, inputPath)
declare function resolvePath(cwd: string, inputPath: string): string
 
// block 级：直接拒绝，没有合法的 Agent 使用场景
const BLOCK_PATTERNS: RegExp[] = [
  /rm\s+-\S*r\S*f\s+(\/|~|\$HOME)\b/, // rm -rf / 或 rm -rf ~
  /dd\s+if=.*of=\/dev\//, // dd 写入磁盘设备
  /mkfs\./, // 格式化文件系统
  />\s*\/dev\/(sda|hda|nvme)/, // 重定向写入磁盘
  /shutdown|reboot|halt/, // 系统关机重启
]
 
// confirm 级：暂停并等待用户明确确认
const CONFIRM_PATTERNS: RegExp[] = [
  /rm\s+-\S*[rf]/, // rm -r 或 rm -f 类
  /sudo\s+/, // sudo 命令
  /curl\s+.*\|\s*(sh|bash|zsh)/, // curl pipe to shell
  /wget\s+.*\|\s*(sh|bash|zsh)/, // wget pipe to shell
  /npm\s+publish/, // 发包
  /git\s+push\s+.*--force/, // 强制推送
  /git\s+reset\s+--hard/, // 硬重置
]
 
export function detectDanger(command: string): DangerLevel {
  if (BLOCK_PATTERNS.some((p) => p.test(command))) return 'block'
  if (CONFIRM_PATTERNS.some((p) => p.test(command))) return 'confirm'
  return 'safe'
}
 
// 路径安全检查：防止路径穿越攻击
export function resolveSafePath(inputPath: string): string {
  const cwd = process.cwd()
  const resolved = resolvePath(cwd, inputPath)
 
  if (!resolved.startsWith(cwd + '/') && resolved !== cwd) {
    throw new Error(
      `路径越界：${inputPath} 解析为 ${resolved}，超出工作目录 ${cwd}`,
    )
  }
 
  return resolved
}
 
// 敏感文件检测
const SENSITIVE_PATTERNS: RegExp[] = [
  /\.env(\.|$)/, // .env 文件
  /\.aws\/credentials/, // AWS 凭证
  /\.ssh\/(id_rsa|id_ed25519)$/, // SSH 私钥
  /secrets?\.(json|yaml|yml)$/i, // secrets 文件
]
 
export function isSensitivePath(path: string): boolean {
  return SENSITIVE_PATTERNS.some((p) => p.test(path))
}
 

// 工具输出截断保护
// 单次工具返回超过此长度时截断，并附加 system_hint 告知 LLM
const MAX_TOOL_OUTPUT = 8_000
 
export function truncateOutput(toolName: string, output: string): string {
  if (output.length <= MAX_TOOL_OUTPUT) return output
 
  const truncated = output.slice(0, MAX_TOOL_OUTPUT)
 
  // 用结构化的 system_hint 告知 LLM 内容被截断，而非直接截断
  // 这样 LLM 不会误以为"内容就这么多"，而是知道还有更多内容
  const hint = [
    '',
    `<system_hint type="tool_output_omitted" tool="${toolName}" reason="too_long"`,
    `             actual_chars="${output.length}" max_chars="${MAX_TOOL_OUTPUT}">`,
    `  工具输出过长，已自动截断。如需完整内容，请用 offset/limit 参数分段调用。`,
    `</system_hint>`,
  ].join('\n')
 
  return truncated + hint
}
 

// 示例省略 import：默认 generateText / CoreMessage / model / TOOLS 已可用
 
export interface RunResult {
  text: string
  responseMessages: CoreMessage[]
  usage: LanguageModelUsage
  stepCount: number
}
 
export async function agentLoop(
  question: string,
  history: CoreMessage[],
  runtimeHints: string[] = [],
): Promise<RunResult> {
  const system = await assembleSystemPrompt(runtimeHints)
 
  const messages: CoreMessage[] = [
    ...history,
    { role: 'user', content: question },
  ]
 
  const result = await generateText({
    model,
    system,
    messages,
    tools: TOOLS,
    maxSteps: 50,
 
    onStepFinish: ({ text, toolCalls, finishReason }) => {
      const isFinalStep = finishReason === 'stop' && toolCalls.length === 0
      if (!isFinalStep) {
        printStep({ text, toolCalls, finishReason })
      }
    },
  })
 
  const stepCount = result.steps.length
  if (stepCount > 1) {
    console.log(`\n\x1b[90m[共执行 ${stepCount} 步]\x1b[0m\n`)
  }
 
  return {
    text: result.text,
    responseMessages: result.response.messages as CoreMessage[],
    usage: result.usage,
    stepCount,
  }
}
 
interface StepInfo {
  text: string
  toolCalls: Array<{ toolName: string; args: unknown }>
}
 
let stepCounter = 0
 
function printStep({ text, toolCalls }: StepInfo) {
  stepCounter++
  console.log(
    `\n\x1b[36m── Step ${stepCounter} ──────────────────────────────────\x1b[0m`,
  )
 
  if (text.trim()) {
    console.log(`\x1b[37m${text.trim()}\x1b[0m`)
  }
 
  for (const call of toolCalls) {
    const argsOneLine = JSON.stringify(call.args)
    const argsPreview =
      argsOneLine.length > 120 ? argsOneLine.slice(0, 120) + '…}' : argsOneLine
    console.log(
      `\n\x1b[32m🔧 ${call.toolName}\x1b[0m \x1b[90m${argsPreview}\x1b[0m`,
    )
  }
}
 
export function resetStepCounter() {
  stepCounter = 0
}
 

const PROMPT_FILE = '../SYSTEM_PROMPT.md'
 
export async function assembleSystemPrompt(
  runtimeHints: string[] = [],
): Promise<string> {
  const segments: string[] = []
 
  // Segment 1: 静态指令
  segments.push(await Bun.file(new URL(PROMPT_FILE, import.meta.url)).text())
 
  // Segment 2: 运行时状态（有则注入）
  if (runtimeHints.length > 0) {
    segments.push('---\n# 运行时状态\n\n' + runtimeHints.join('\n\n'))
  }
 
  return segments.join('\n\n')
}
 

// 示例省略 import：默认 CoreMessage / generateText / model 已可用
 
const MODEL_CONTEXT_LIMIT = 128_000
const COMPRESS_THRESHOLD = 0.8
 
// 使用 SDK 返回的真实 promptTokens 判断是否需要压缩
export function shouldCompress(promptTokens: number): boolean {
  return promptTokens > MODEL_CONTEXT_LIMIT * COMPRESS_THRESHOLD
}
 
// 将完整 history 压缩为结构化摘要
export async function compressHistory(history: CoreMessage[]): Promise<string> {
  const COMPRESS_SYSTEM = `
你是一个 Agent 执行历史压缩器。将以下执行历史总结为结构化摘要，输出格式如下：
 
<completed>
已完成的具体操作（每行一条，保留关键细节）
</completed>
 
<remaining>
还未完成的任务或子任务
</remaining>
 
<current_state>
当前状态：已修改的文件路径、关键变量、环境状态等
</current_state>
 
<notes>
注意事项：踩过的坑、特殊处理、边界条件
</notes>
 
要求：信息密度高，去掉废话，保留所有对后续执行有用的细节。
`.trim()
 
  const historyText = history
    .map((m) => {
      const content =
        typeof m.content === 'string' ? m.content : JSON.stringify(m.content)
      return `[${m.role}]\n${content}`
    })
    .join('\n\n---\n\n')
 
  const { text } = await generateText({
    model,
    system: COMPRESS_SYSTEM,
    prompt: historyText,
    maxSteps: 1,
  })
 
  return text
}
 
// 用压缩摘要重建运行时 hint，注入到下一轮系统提示词
export function buildCompressionHint(summary: string): string {
  return [
    '[执行历史摘要 - 之前会话已压缩]',
    '',
    summary,
    '',
    '注意：以上是对之前执行历史的摘要，你处于重建会话状态。',
    '请基于摘要继续完成原始任务，不要重复已完成的操作。',
  ].join('\n')
}
 

// 示例省略 import：默认 readline / agentLoop / context helpers 已可用
// 并假设 CoreMessage 类型已在项目中定义
 
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
})
 
// 维护跨轮对话的消息历史（不含系统提示词，generateText 单独传 system）
let history: CoreMessage[] = []
// 运行时 hint 列表（如压缩摘要，下一轮会注入系统提示词）
let runtimeHints: string[] = []
 
function prompt() {
  rl.question('\n\x1b[34m> \x1b[0m', async (input) => {
    const question = input.trim()
 
    if (question === '/exit' || question === '/quit') {
      console.log('再见！')
      rl.close()
      return
    }
 
    if (question === '/reset') {
      history = []
      runtimeHints = []
      console.log('\x1b[90m[会话已重置]\x1b[0m')
      prompt()
      return
    }
 
    if (question === '/help') {
      printHelp()
      prompt()
      return
    }
 
    if (!question) {
      prompt()
      return
    }
 
    resetStepCounter()
 
    try {
      const { text, responseMessages, usage, stepCount } = await agentLoop(
        question,
        history,
        runtimeHints,
      )
 
      // 将本轮消息（含所有中间工具调用步骤）追加到 history
      history.push({ role: 'user', content: question })
      history.push(...responseMessages)
 
      if (stepCount > 1) {
        console.log(
          `\n\x1b[36m── 最终回答 ─────────────────────────────────────\x1b[0m`,
        )
      }
      console.log(text)
 
      // 上下文压缩检查（基于 SDK 返回的真实 token 用量）
      if (shouldCompress(usage.promptTokens)) {
        console.log('\n\x1b[33m[上下文接近上限，正在压缩...]\x1b[0m')
        try {
          const summary = await compressHistory(history)
          const hint = buildCompressionHint(summary)
          history = []
          runtimeHints = [hint]
          console.log('\x1b[90m[上下文已压缩，下次对话继续]\x1b[0m')
        } catch (e) {
          console.warn(`\x1b[33m[压缩失败: ${(e as Error).message}]\x1b[0m`)
        }
      }
    } catch (e) {
      console.error(`\n\x1b[31m[错误] ${(e as Error).message}\x1b[0m`)
    }
 
    prompt()
  })
}
 
function printHelp() {
  console.log(`
\x1b[1mmini-claude-code\x1b[0m — 教学用 Code Agent
 
\x1b[1m可用命令：\x1b[0m
  /reset   清空当前会话历史，重新开始
  /exit    退出
  /help    显示此帮助
 
\x1b[1m可用工具：\x1b[0m
  read_file   读取文件
  write_file  写入文件
  edit_file   局部编辑文件
  bash        执行 Shell 命令
  web_fetch   抓取网页内容
`)
}
 
console.log(
  `\x1b[1mmini-claude-code\x1b[0m \x1b[90mv0.1.0 — 输入 /help 查看帮助\x1b[0m\n`,
)
prompt()