799 lines
36 KiB
Python
799 lines
36 KiB
Python
import asyncio
|
||
import json
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
from typing import Any, Dict, List, Optional, Set
|
||
|
||
try:
|
||
from config import (
|
||
OUTPUT_FORMATS, DATA_DIR, PROMPTS_DIR, NEED_CONFIRMATION,
|
||
MAX_TERMINALS, TERMINAL_BUFFER_SIZE, TERMINAL_DISPLAY_SIZE,
|
||
MAX_READ_FILE_CHARS, READ_TOOL_DEFAULT_MAX_CHARS,
|
||
READ_TOOL_DEFAULT_CONTEXT_BEFORE, READ_TOOL_DEFAULT_CONTEXT_AFTER,
|
||
READ_TOOL_MAX_CONTEXT_BEFORE, READ_TOOL_MAX_CONTEXT_AFTER,
|
||
READ_TOOL_DEFAULT_MAX_MATCHES, READ_TOOL_MAX_MATCHES,
|
||
READ_TOOL_MAX_FILE_SIZE,
|
||
TERMINAL_SANDBOX_MOUNT_PATH,
|
||
TERMINAL_SANDBOX_MODE,
|
||
TERMINAL_SANDBOX_CPUS,
|
||
TERMINAL_SANDBOX_MEMORY,
|
||
PROJECT_MAX_STORAGE_MB,
|
||
CUSTOM_TOOLS_ENABLED,
|
||
)
|
||
except ImportError:
|
||
import sys
|
||
project_root = Path(__file__).resolve().parents[2]
|
||
if str(project_root) not in sys.path:
|
||
sys.path.insert(0, str(project_root))
|
||
from config import (
|
||
OUTPUT_FORMATS, DATA_DIR, PROMPTS_DIR, NEED_CONFIRMATION,
|
||
MAX_TERMINALS, TERMINAL_BUFFER_SIZE, TERMINAL_DISPLAY_SIZE,
|
||
MAX_READ_FILE_CHARS, READ_TOOL_DEFAULT_MAX_CHARS,
|
||
READ_TOOL_DEFAULT_CONTEXT_BEFORE, READ_TOOL_DEFAULT_CONTEXT_AFTER,
|
||
READ_TOOL_MAX_CONTEXT_BEFORE, READ_TOOL_MAX_CONTEXT_AFTER,
|
||
READ_TOOL_DEFAULT_MAX_MATCHES, READ_TOOL_MAX_MATCHES,
|
||
READ_TOOL_MAX_FILE_SIZE,
|
||
TERMINAL_SANDBOX_MOUNT_PATH,
|
||
TERMINAL_SANDBOX_MODE,
|
||
TERMINAL_SANDBOX_CPUS,
|
||
TERMINAL_SANDBOX_MEMORY,
|
||
PROJECT_MAX_STORAGE_MB,
|
||
CUSTOM_TOOLS_ENABLED,
|
||
)
|
||
|
||
from modules.file_manager import FileManager
|
||
from modules.search_engine import SearchEngine
|
||
from modules.terminal_ops import TerminalOperator
|
||
from modules.memory_manager import MemoryManager
|
||
from modules.terminal_manager import TerminalManager
|
||
from modules.todo_manager import TodoManager
|
||
from modules.sub_agent_manager import SubAgentManager
|
||
from modules.webpage_extractor import extract_webpage_content, tavily_extract
|
||
from modules.ocr_client import OCRClient
|
||
from modules.easter_egg_manager import EasterEggManager
|
||
from modules.personalization_manager import (
|
||
load_personalization_config,
|
||
build_personalization_prompt,
|
||
)
|
||
from modules.skills_manager import (
|
||
get_skills_catalog,
|
||
build_skills_list,
|
||
merge_enabled_skills,
|
||
build_skills_prompt,
|
||
)
|
||
from modules.custom_tool_registry import CustomToolRegistry, build_default_tool_category
|
||
from modules.custom_tool_executor import CustomToolExecutor
|
||
|
||
try:
|
||
from config.limits import THINKING_FAST_INTERVAL
|
||
except ImportError:
|
||
THINKING_FAST_INTERVAL = 10
|
||
|
||
from modules.container_monitor import collect_stats, inspect_state
|
||
from core.tool_config import TOOL_CATEGORIES
|
||
from utils.api_client import DeepSeekClient
|
||
from utils.context_manager import ContextManager
|
||
from utils.tool_result_formatter import format_tool_result_for_context
|
||
from utils.logger import setup_logger
|
||
from config.model_profiles import (
|
||
get_model_profile,
|
||
get_model_prompt_replacements,
|
||
get_model_context_window,
|
||
)
|
||
|
||
logger = setup_logger(__name__)
|
||
DISABLE_LENGTH_CHECK = True
|
||
|
||
class MainTerminalCommandMixin:
|
||
async def run(self):
|
||
"""运行主终端循环"""
|
||
print(f"\n{OUTPUT_FORMATS['info']} 主终端已启动")
|
||
print(f"{OUTPUT_FORMATS['info']} 当前对话: {self.context_manager.current_conversation_id}")
|
||
|
||
while True:
|
||
try:
|
||
# 获取用户输入（使用人的表情）
|
||
user_input = input("\n👤 > ").strip()
|
||
|
||
if not user_input:
|
||
continue
|
||
|
||
# 处理命令（命令不记录到对话历史）
|
||
if user_input.startswith('/'):
|
||
await self.handle_command(user_input[1:])
|
||
elif user_input.lower() in ['exit', 'quit', 'q']:
|
||
# 用户可能忘记加斜杠
|
||
print(f"{OUTPUT_FORMATS['info']} 提示: 使用 /exit 退出系统")
|
||
continue
|
||
elif user_input.lower() == 'help':
|
||
print(f"{OUTPUT_FORMATS['info']} 提示: 使用 /help 查看帮助")
|
||
continue
|
||
else:
|
||
# 确保有活动对话
|
||
self._ensure_conversation()
|
||
|
||
# 只有非命令的输入才记录到对话历史
|
||
self.context_manager.add_conversation("user", user_input)
|
||
|
||
# 新增：开始新的任务会话
|
||
self.current_session_id += 1
|
||
|
||
# AI回复前空一行，并显示机器人图标
|
||
print("\n🤖 >", end=" ")
|
||
await self.handle_task(user_input)
|
||
# 回复后自动空一行（在handle_task完成后）
|
||
|
||
except KeyboardInterrupt:
|
||
print(f"\n{OUTPUT_FORMATS['warning']} 使用 /exit 退出系统")
|
||
continue
|
||
except Exception as e:
|
||
logger.error(f"主终端错误: {e}", exc_info=True)
|
||
print(f"{OUTPUT_FORMATS['error']} 发生错误: {e}")
|
||
# 错误后仍然尝试自动保存
|
||
try:
|
||
self.context_manager.auto_save_conversation()
|
||
except:
|
||
pass
|
||
|
||
async def handle_command(self, command: str):
|
||
"""处理系统命令"""
|
||
parts = command.split(maxsplit=1)
|
||
cmd = parts[0].lower()
|
||
args = parts[1] if len(parts) > 1 else ""
|
||
|
||
if cmd in self.commands:
|
||
await self.commands[cmd](args)
|
||
else:
|
||
print(f"{OUTPUT_FORMATS['error']} 未知命令: {cmd}")
|
||
await self.show_help()
|
||
|
||
async def handle_task(self, user_input: str):
|
||
"""处理用户任务（完全修复版：彻底解决对话记录重复问题）"""
|
||
try:
|
||
# 如果是思考模式，每个新任务重置状态
|
||
# 注意：这里重置的是当前任务的第一次调用标志，确保新用户请求重新思考
|
||
if self.thinking_mode:
|
||
self.api_client.start_new_task(force_deep=self.deep_thinking_mode)
|
||
|
||
# 新增：开始新的任务会话
|
||
self.current_session_id += 1
|
||
|
||
# === 上下文预算与安全校验 ===
|
||
current_tokens = self.context_manager.get_current_context_tokens()
|
||
max_context_tokens = get_model_context_window(self.model_key)
|
||
if max_context_tokens:
|
||
if current_tokens >= max_context_tokens:
|
||
msg = (
|
||
f"当前对话上下文已达 {current_tokens} tokens，"
|
||
f"超过模型上限 {max_context_tokens}，请先压缩或清理上下文后再试。"
|
||
)
|
||
print(f"{OUTPUT_FORMATS['error']} {msg}")
|
||
# 记录一条系统消息，方便回溯
|
||
self.context_manager.add_conversation("system", msg)
|
||
return
|
||
usage_percent = (current_tokens / max_context_tokens) * 100
|
||
warned = self.context_manager.conversation_metadata.get("context_warning_sent", False)
|
||
if usage_percent >= 70 and not warned:
|
||
warn_msg = (
|
||
f"当前上下文约占 {usage_percent:.1f}%（{current_tokens}/{max_context_tokens}），"
|
||
"建议使用压缩功能。"
|
||
)
|
||
print(f"{OUTPUT_FORMATS['warning']} {warn_msg}")
|
||
self.context_manager.conversation_metadata["context_warning_sent"] = True
|
||
self.context_manager.auto_save_conversation(force=True)
|
||
# 将上下文预算传给API客户端，动态调整 max_tokens
|
||
self.api_client.update_context_budget(current_tokens, max_context_tokens)
|
||
|
||
# 构建上下文
|
||
context = self.build_context()
|
||
|
||
# 构建消息
|
||
messages = self.build_messages(context, user_input)
|
||
|
||
# 定义可用工具
|
||
tools = self.define_tools()
|
||
|
||
# 用于收集本次任务的所有信息（关键：不立即保存到对话历史）
|
||
collected_tool_calls = []
|
||
collected_tool_results = []
|
||
final_response = ""
|
||
final_thinking = ""
|
||
|
||
# 工具处理器：只执行工具，收集信息，绝不保存到对话历史
|
||
async def tool_handler(tool_name: str, arguments: Dict) -> str:
|
||
# 执行工具调用
|
||
result = await self.handle_tool_call(tool_name, arguments)
|
||
|
||
# 生成工具调用ID
|
||
tool_call_id = f"call_{datetime.now().timestamp()}_{tool_name}"
|
||
|
||
# 收集工具调用信息（不保存）
|
||
tool_call_info = {
|
||
"id": tool_call_id,
|
||
"type": "function",
|
||
"function": {
|
||
"name": tool_name,
|
||
"arguments": json.dumps(arguments, ensure_ascii=False)
|
||
}
|
||
}
|
||
collected_tool_calls.append(tool_call_info)
|
||
|
||
# 处理工具结果用于保存
|
||
try:
|
||
parsed = json.loads(result)
|
||
result_data = parsed if isinstance(parsed, dict) else {}
|
||
except Exception:
|
||
result_data = {}
|
||
tool_result_content = format_tool_result_for_context(tool_name, result_data, result)
|
||
tool_images = None
|
||
tool_videos = None
|
||
if (
|
||
isinstance(result_data, dict)
|
||
and result_data.get("success") is not False
|
||
):
|
||
if tool_name == "view_image":
|
||
img_path = result_data.get("path")
|
||
if img_path:
|
||
tool_images = [img_path]
|
||
elif tool_name == "view_video":
|
||
video_path = result_data.get("path")
|
||
if video_path:
|
||
tool_videos = [video_path]
|
||
|
||
# 收集工具结果（不保存）
|
||
collected_tool_results.append({
|
||
"tool_call_id": tool_call_id,
|
||
"name": tool_name,
|
||
"content": tool_result_content,
|
||
"system_message": result_data.get("system_message") if isinstance(result_data, dict) else None,
|
||
"task_id": result_data.get("task_id") if isinstance(result_data, dict) else None,
|
||
"raw_result_data": result_data if result_data else None,
|
||
"images": tool_images,
|
||
"videos": tool_videos,
|
||
})
|
||
|
||
return result
|
||
|
||
# 调用带工具的API（模型自己决定是否使用工具）
|
||
response = await self.api_client.chat_with_tools(
|
||
messages=messages,
|
||
tools=tools,
|
||
tool_handler=tool_handler
|
||
)
|
||
|
||
# 保存响应内容
|
||
final_response = response
|
||
|
||
# 获取思考内容（如果有的话）
|
||
if self.api_client.current_task_thinking:
|
||
final_thinking = self.api_client.current_task_thinking
|
||
|
||
# ===== 统一保存到对话历史（关键修复） =====
|
||
|
||
# 1. 构建助手回复内容（思考内容通过 reasoning_content 存储）
|
||
assistant_content = final_response or "已完成操作。"
|
||
|
||
# 2. 保存assistant消息（包含tool_calls但不包含结果）
|
||
self.context_manager.add_conversation(
|
||
"assistant",
|
||
assistant_content,
|
||
collected_tool_calls if collected_tool_calls else None,
|
||
reasoning_content=final_thinking or None
|
||
)
|
||
|
||
# 3. 保存独立的tool消息
|
||
for tool_result in collected_tool_results:
|
||
self.context_manager.add_conversation(
|
||
"tool",
|
||
tool_result["content"],
|
||
tool_call_id=tool_result["tool_call_id"],
|
||
name=tool_result["name"],
|
||
images=tool_result.get("images"),
|
||
videos=tool_result.get("videos")
|
||
)
|
||
system_message = tool_result.get("system_message")
|
||
if system_message:
|
||
self._record_sub_agent_message(system_message, tool_result.get("task_id"), inline=False)
|
||
|
||
# 4. 在终端显示执行信息（不保存到历史）
|
||
if collected_tool_calls:
|
||
tool_names = [tc['function']['name'] for tc in collected_tool_calls]
|
||
|
||
for tool_name in tool_names:
|
||
if tool_name == "create_file":
|
||
print(f"{OUTPUT_FORMATS['file']} 创建文件")
|
||
elif tool_name == "read_file":
|
||
print(f"{OUTPUT_FORMATS['file']} 读取文件")
|
||
elif tool_name in {"vlm_analyze", "ocr_image"}:
|
||
print(f"{OUTPUT_FORMATS['file']} VLM 视觉理解")
|
||
elif tool_name == "write_file":
|
||
print(f"{OUTPUT_FORMATS['file']} 写入文件")
|
||
elif tool_name == "edit_file":
|
||
print(f"{OUTPUT_FORMATS['file']} 编辑文件")
|
||
elif tool_name == "delete_file":
|
||
print(f"{OUTPUT_FORMATS['file']} 删除文件")
|
||
elif tool_name == "terminal_session":
|
||
print(f"{OUTPUT_FORMATS['session']} 终端会话操作")
|
||
elif tool_name == "terminal_input":
|
||
print(f"{OUTPUT_FORMATS['terminal']} 执行终端命令")
|
||
elif tool_name == "web_search":
|
||
print(f"{OUTPUT_FORMATS['search']} 网络搜索")
|
||
elif tool_name == "run_python":
|
||
print(f"{OUTPUT_FORMATS['code']} 执行Python代码")
|
||
elif tool_name == "run_command":
|
||
print(f"{OUTPUT_FORMATS['terminal']} 执行系统命令")
|
||
elif tool_name == "update_memory":
|
||
print(f"{OUTPUT_FORMATS['memory']} 更新记忆")
|
||
elif tool_name == "sleep":
|
||
print(f"{OUTPUT_FORMATS['info']} 等待操作")
|
||
else:
|
||
print(f"{OUTPUT_FORMATS['action']} 执行: {tool_name}")
|
||
|
||
if len(tool_names) > 1:
|
||
print(f"{OUTPUT_FORMATS['info']} 共执行 {len(tool_names)} 个操作")
|
||
|
||
except Exception as e:
|
||
logger.error(f"任务处理错误: {e}", exc_info=True)
|
||
print(f"{OUTPUT_FORMATS['error']} 任务处理失败: {e}")
|
||
# 错误时也尝试自动保存
|
||
try:
|
||
self.context_manager.auto_save_conversation()
|
||
except:
|
||
pass
|
||
|
||
async def show_conversations(self, args: str = ""):
|
||
"""显示对话列表"""
|
||
try:
|
||
limit = 10 # 默认显示最近10个对话
|
||
if args:
|
||
try:
|
||
limit = int(args)
|
||
limit = max(1, min(limit, 50)) # 限制在1-50之间
|
||
except ValueError:
|
||
print(f"{OUTPUT_FORMATS['warning']} 无效数量，使用默认值10")
|
||
limit = 10
|
||
|
||
conversations = self.context_manager.get_conversation_list(limit=limit)
|
||
|
||
if not conversations["conversations"]:
|
||
print(f"{OUTPUT_FORMATS['info']} 暂无对话记录")
|
||
return
|
||
|
||
print(f"\n📚 最近 {len(conversations['conversations'])} 个对话:")
|
||
print("="*70)
|
||
|
||
for i, conv in enumerate(conversations["conversations"], 1):
|
||
# 状态图标
|
||
status_icon = "🟢" if conv["status"] == "active" else "📦" if conv["status"] == "archived" else "❌"
|
||
|
||
# 当前对话标记
|
||
current_mark = " [当前]" if conv["id"] == self.context_manager.current_conversation_id else ""
|
||
|
||
# 思考模式标记
|
||
mode_mark = "💭" if conv["thinking_mode"] else "⚡"
|
||
|
||
print(f"{i:2d}. {status_icon} {conv['id'][:16]}...{current_mark}")
|
||
print(f" {mode_mark} {conv['title'][:50]}{'...' if len(conv['title']) > 50 else ''}")
|
||
print(f" 📅 {conv['updated_at'][:19]} | 💬 {conv['total_messages']} 条消息 | 🔧 {conv['total_tools']} 个工具")
|
||
print(f" 📁 {conv['project_path']}")
|
||
print()
|
||
|
||
print(f"总计: {conversations['total']} 个对话")
|
||
if conversations["has_more"]:
|
||
print(f"使用 /conversations {limit + 10} 查看更多")
|
||
|
||
except Exception as e:
|
||
print(f"{OUTPUT_FORMATS['error']} 获取对话列表失败: {e}")
|
||
|
||
async def load_conversation_command(self, args: str):
|
||
"""加载指定对话"""
|
||
if not args:
|
||
print(f"{OUTPUT_FORMATS['error']} 请指定对话ID")
|
||
print("使用方法: /load <对话ID>")
|
||
await self.show_conversations("5") # 显示最近5个对话作为提示
|
||
return
|
||
|
||
conversation_id = args.strip()
|
||
|
||
try:
|
||
success = self.context_manager.load_conversation_by_id(conversation_id)
|
||
if success:
|
||
print(f"{OUTPUT_FORMATS['success']} 对话已加载: {conversation_id}")
|
||
print(f"{OUTPUT_FORMATS['info']} 消息数量: {len(self.context_manager.conversation_history)}")
|
||
|
||
# 如果是思考模式，重置状态（下次任务会重新思考）
|
||
if self.thinking_mode:
|
||
self.api_client.start_new_task(force_deep=self.deep_thinking_mode)
|
||
|
||
self.current_session_id += 1
|
||
|
||
else:
|
||
print(f"{OUTPUT_FORMATS['error']} 对话加载失败")
|
||
|
||
except Exception as e:
|
||
print(f"{OUTPUT_FORMATS['error']} 加载对话异常: {e}")
|
||
|
||
async def new_conversation_command(self, args: str = ""):
|
||
"""创建新对话"""
|
||
try:
|
||
conversation_id = self.context_manager.start_new_conversation(
|
||
project_path=self.project_path,
|
||
thinking_mode=self.thinking_mode
|
||
)
|
||
|
||
print(f"{OUTPUT_FORMATS['success']} 已创建新对话: {conversation_id}")
|
||
|
||
# 重置相关状态
|
||
if self.thinking_mode:
|
||
self.api_client.start_new_task(force_deep=self.deep_thinking_mode)
|
||
|
||
self.current_session_id += 1
|
||
|
||
except Exception as e:
|
||
print(f"{OUTPUT_FORMATS['error']} 创建新对话失败: {e}")
|
||
|
||
async def save_conversation_command(self, args: str = ""):
|
||
"""手动保存当前对话"""
|
||
try:
|
||
success = self.context_manager.save_current_conversation()
|
||
if success:
|
||
print(f"{OUTPUT_FORMATS['success']} 对话已保存")
|
||
else:
|
||
print(f"{OUTPUT_FORMATS['error']} 对话保存失败")
|
||
except Exception as e:
|
||
print(f"{OUTPUT_FORMATS['error']} 保存对话异常: {e}")
|
||
|
||
async def clear_conversation(self, args: str = ""):
|
||
"""清除对话记录（修改版：创建新对话而不是清空）"""
|
||
if input("确认创建新对话? 当前对话将被保存 (y/n): ").lower() == 'y':
|
||
try:
|
||
# 保存当前对话
|
||
if self.context_manager.current_conversation_id:
|
||
self.context_manager.save_current_conversation()
|
||
|
||
# 创建新对话
|
||
await self.new_conversation_command()
|
||
|
||
print(f"{OUTPUT_FORMATS['success']} 已开始新对话")
|
||
|
||
except Exception as e:
|
||
print(f"{OUTPUT_FORMATS['error']} 创建新对话失败: {e}")
|
||
|
||
async def show_status(self, args: str = ""):
|
||
"""显示系统状态"""
|
||
# 上下文状态
|
||
context_status = self.context_manager.check_context_size()
|
||
|
||
# 记忆状态
|
||
memory_stats = self.memory_manager.get_memory_stats()
|
||
|
||
# 文件结构
|
||
structure = self.context_manager.get_project_structure()
|
||
|
||
# 终端会话状态
|
||
terminal_status = self.terminal_manager.list_terminals()
|
||
|
||
# 思考模式状态
|
||
thinking_status = self.get_run_mode_label()
|
||
if self.thinking_mode:
|
||
thinking_status += f" ({'等待新任务' if self.api_client.current_task_first_call else '任务进行中'})"
|
||
|
||
# 新增：对话统计
|
||
conversation_stats = self.context_manager.get_conversation_statistics()
|
||
|
||
status_text = f"""
|
||
📊 系统状态:
|
||
项目路径: {self.project_path}
|
||
运行模式: {thinking_status}
|
||
当前对话: {self.context_manager.current_conversation_id or '无'}
|
||
|
||
上下文使用: {context_status['usage_percent']:.1f}%
|
||
当前消息: {len(self.context_manager.conversation_history)} 条
|
||
终端会话: {terminal_status['total']}/{terminal_status['max_allowed']} 个
|
||
当前会话ID: {self.current_session_id}
|
||
|
||
项目文件: {structure['total_files']} 个
|
||
项目大小: {structure['total_size'] / 1024 / 1024:.2f} MB
|
||
|
||
对话总数: {conversation_stats.get('total_conversations', 0)} 个
|
||
历史消息: {conversation_stats.get('total_messages', 0)} 条
|
||
工具调用: {conversation_stats.get('total_tools', 0)} 次
|
||
|
||
主记忆: {memory_stats['main_memory']['lines']} 行
|
||
任务记忆: {memory_stats['task_memory']['lines']} 行
|
||
"""
|
||
container_report = self._container_status_report()
|
||
if container_report:
|
||
status_text += container_report
|
||
print(status_text)
|
||
|
||
def _container_status_report(self) -> str:
|
||
session = getattr(self, "container_session", None)
|
||
if not session or session.mode != "docker":
|
||
return ""
|
||
stats = collect_stats(session.container_name, session.sandbox_bin)
|
||
state = inspect_state(session.container_name, session.sandbox_bin)
|
||
lines = [f" 容器: {session.container_name or '未知'}"]
|
||
if stats:
|
||
cpu = stats.get("cpu_percent")
|
||
mem = stats.get("memory", {})
|
||
net = stats.get("net_io", {})
|
||
block = stats.get("block_io", {})
|
||
lines.append(f" CPU: {cpu:.2f}%" if cpu is not None else " CPU: 未知")
|
||
if mem:
|
||
used = mem.get("used_bytes")
|
||
limit = mem.get("limit_bytes")
|
||
percent = mem.get("percent")
|
||
mem_line = " 内存: "
|
||
if used is not None:
|
||
mem_line += f"{used / (1024 * 1024):.2f}MB"
|
||
if limit:
|
||
mem_line += f" / {limit / (1024 * 1024):.2f}MB"
|
||
if percent is not None:
|
||
mem_line += f" ({percent:.2f}%)"
|
||
lines.append(mem_line)
|
||
if net:
|
||
rx = net.get("rx_bytes") or 0
|
||
tx = net.get("tx_bytes") or 0
|
||
lines.append(f" 网络: ↓{rx/1024:.1f}KB ↑{tx/1024:.1f}KB")
|
||
if block:
|
||
read = block.get("read_bytes") or 0
|
||
write = block.get("write_bytes") or 0
|
||
lines.append(f" 磁盘: 读 {read/1024:.1f}KB / 写 {write/1024:.1f}KB")
|
||
else:
|
||
lines.append(" 指标: 暂无")
|
||
if state:
|
||
lines.append(f" 状态: {state.get('status')}")
|
||
return "\n".join(lines) + "\n"
|
||
|
||
async def save_state(self):
|
||
"""保存状态"""
|
||
try:
|
||
# 保存对话历史（使用新的持久化系统）
|
||
self.context_manager.save_current_conversation()
|
||
|
||
# 保存文件备注
|
||
self.context_manager.save_annotations()
|
||
|
||
print(f"{OUTPUT_FORMATS['success']} 状态已保存")
|
||
except Exception as e:
|
||
print(f"{OUTPUT_FORMATS['error']} 状态保存失败: {e}")
|
||
|
||
async def show_help(self, args: str = ""):
|
||
"""显示帮助信息"""
|
||
# 根据当前模式显示不同的帮助信息
|
||
mode_info = ""
|
||
if self.thinking_mode:
|
||
mode_info = "\n💡 思考模式:\n - 每个新任务首次调用深度思考\n - 同一任务后续调用快速响应\n - 每个新任务都会重新思考"
|
||
else:
|
||
mode_info = "\n⚡ 快速模式:\n - 不进行思考，直接响应\n - 适合简单任务和快速交互"
|
||
|
||
help_text = f"""
|
||
📚 可用命令:
|
||
/help - 显示此帮助信息
|
||
/exit - 退出系统
|
||
/status - 显示系统状态
|
||
/memory - 管理记忆
|
||
/clear - 创建新对话
|
||
/history - 显示对话历史
|
||
/files - 显示项目文件
|
||
/focused - 显示聚焦文件
|
||
/terminals - 显示终端会话
|
||
/mode - 切换运行模式
|
||
|
||
🗂️ 对话管理:
|
||
/conversations [数量] - 显示对话列表
|
||
/load <对话ID> - 加载指定对话
|
||
/new - 创建新对话
|
||
/save - 手动保存当前对话
|
||
|
||
💡 使用提示:
|
||
- 直接输入任务描述，系统会自动判断是否需要执行
|
||
- 使用 Ctrl+C 可以中断当前操作
|
||
- 重要操作会要求确认
|
||
- 所有对话都会自动保存，不用担心丢失
|
||
|
||
🔍 文件聚焦功能:
|
||
- 系统可以聚焦最多3个文件，实现"边看边改"
|
||
- 聚焦的文件内容会持续显示在上下文中
|
||
- 适合需要频繁查看和修改的文件
|
||
|
||
📺 持久化终端:
|
||
- 可以打开最多3个终端会话
|
||
- 终端保持运行状态，支持交互式程序
|
||
- 使用 terminal_session 和 terminal_input 工具控制{mode_info}
|
||
"""
|
||
print(help_text)
|
||
|
||
async def show_terminals(self, args: str = ""):
|
||
"""显示终端会话列表"""
|
||
result = self.terminal_manager.list_terminals()
|
||
|
||
if result["total"] == 0:
|
||
print(f"{OUTPUT_FORMATS['info']} 当前没有活动的终端会话")
|
||
else:
|
||
print(f"\n📺 终端会话列表 ({result['total']}/{result['max_allowed']}):")
|
||
print("="*50)
|
||
for session in result["sessions"]:
|
||
status_icon = "🟢" if session["is_running"] else "🔴"
|
||
active_mark = " [活动]" if session["is_active"] else ""
|
||
print(f" {status_icon} {session['session_name']}{active_mark}")
|
||
print(f" 工作目录: {session['working_dir']}")
|
||
print(f" Shell: {session['shell']}")
|
||
print(f" 运行时间: {session['uptime_seconds']:.1f}秒")
|
||
if session["is_interactive"]:
|
||
print(f" ⚠️ 等待输入")
|
||
print("="*50)
|
||
|
||
async def exit_system(self, args: str = ""):
|
||
"""退出系统"""
|
||
print(f"{OUTPUT_FORMATS['info']} 正在退出...")
|
||
|
||
# 关闭所有终端会话
|
||
self.terminal_manager.close_all()
|
||
|
||
# 保存状态
|
||
await self.save_state()
|
||
|
||
exit(0)
|
||
|
||
async def manage_memory(self, args: str = ""):
|
||
"""管理记忆"""
|
||
if not args:
|
||
print("""
|
||
🧠 记忆管理:
|
||
/memory show [main|task] - 显示记忆内容
|
||
/memory edit [main|task] - 编辑记忆
|
||
/memory clear task - 清空任务记忆
|
||
/memory merge - 合并任务记忆到主记忆
|
||
/memory backup [main|task]- 备份记忆
|
||
""")
|
||
return
|
||
|
||
parts = args.split()
|
||
action = parts[0] if parts else ""
|
||
target = parts[1] if len(parts) > 1 else "main"
|
||
|
||
if action == "show":
|
||
if target == "main":
|
||
content = self.memory_manager.read_main_memory()
|
||
else:
|
||
content = self.memory_manager.read_task_memory()
|
||
print(f"\n{'='*50}")
|
||
print(content)
|
||
print('='*50)
|
||
|
||
elif action == "clear" and target == "task":
|
||
if input("确认清空任务记忆? (y/n): ").lower() == 'y':
|
||
self.memory_manager.clear_task_memory()
|
||
|
||
elif action == "merge":
|
||
self.memory_manager.merge_memories()
|
||
|
||
elif action == "backup":
|
||
path = self.memory_manager.backup_memory(target)
|
||
if path:
|
||
print(f"备份保存到: {path}")
|
||
|
||
async def show_history(self, args: str = ""):
|
||
"""显示对话历史"""
|
||
history = self.context_manager.conversation_history[-2000:] # 最近2000条
|
||
|
||
print("\n📜 对话历史:")
|
||
print("="*50)
|
||
for conv in history:
|
||
timestamp = conv.get("timestamp", "")
|
||
if conv["role"] == "user":
|
||
role = "👤 用户"
|
||
elif conv["role"] == "assistant":
|
||
role = "🤖 助手"
|
||
elif conv["role"] == "tool":
|
||
role = f"🔧 工具[{conv.get('name', 'unknown')}]"
|
||
else:
|
||
role = conv["role"]
|
||
|
||
content = conv["content"][:100] + "..." if len(conv["content"]) > 100 else conv["content"]
|
||
print(f"\n[{timestamp[:19]}] {role}:")
|
||
print(content)
|
||
|
||
# 如果是助手消息且有工具调用，显示工具信息
|
||
if conv["role"] == "assistant" and "tool_calls" in conv and conv["tool_calls"]:
|
||
tools = [tc["function"]["name"] for tc in conv["tool_calls"]]
|
||
print(f" 🔗 调用工具: {', '.join(tools)}")
|
||
print("="*50)
|
||
|
||
async def show_files(self, args: str = ""):
|
||
"""显示项目文件"""
|
||
if self.context_manager._is_host_mode_without_safety():
|
||
print("\n⚠️ 宿主机模式下文件树不可用")
|
||
return
|
||
structure = self.context_manager.get_project_structure()
|
||
print(f"\n📁 项目文件结构:")
|
||
print(self.context_manager._build_file_tree(structure))
|
||
print(f"\n总计: {structure['total_files']} 个文件, {structure['total_size'] / 1024 / 1024:.2f} MB")
|
||
|
||
def set_run_mode(self, mode: str) -> str:
|
||
"""统一设置运行模式"""
|
||
allowed = ["fast", "thinking", "deep"]
|
||
normalized = mode.lower()
|
||
if normalized not in allowed:
|
||
raise ValueError(f"不支持的模式: {mode}")
|
||
# 仅深度思考模型限制
|
||
if getattr(self, "model_profile", {}).get("deep_only") and normalized != "deep":
|
||
raise ValueError("当前模型仅支持深度思考模式")
|
||
# fast-only 模型限制
|
||
if getattr(self, "model_profile", {}).get("fast_only") and normalized != "fast":
|
||
raise ValueError("当前模型仅支持快速模式")
|
||
previous_mode = getattr(self, "run_mode", "fast")
|
||
self.run_mode = normalized
|
||
self.thinking_mode = normalized != "fast"
|
||
self.deep_thinking_mode = normalized == "deep"
|
||
self.api_client.thinking_mode = self.thinking_mode
|
||
self.api_client.set_deep_thinking_mode(self.deep_thinking_mode)
|
||
if self.deep_thinking_mode:
|
||
self.api_client.force_thinking_next_call = False
|
||
self.api_client.skip_thinking_next_call = False
|
||
if not self.thinking_mode:
|
||
self.api_client.start_new_task()
|
||
elif previous_mode == "deep" and normalized != "deep":
|
||
self.api_client.start_new_task()
|
||
return self.run_mode
|
||
|
||
def apply_model_profile(self, profile: dict):
|
||
"""将模型配置应用到 API 客户端"""
|
||
if not profile:
|
||
return
|
||
self.api_client.apply_profile(profile)
|
||
|
||
def set_model(self, model_key: str) -> str:
|
||
profile = get_model_profile(model_key)
|
||
if getattr(self.context_manager, "has_images", False) and model_key not in {"qwen3-vl-plus", "kimi-k2.5"}:
|
||
raise ValueError("当前对话包含图片，仅支持 Qwen3.5 或 Kimi-k2.5")
|
||
if getattr(self.context_manager, "has_videos", False) and model_key not in {"qwen3-vl-plus", "kimi-k2.5"}:
|
||
raise ValueError("当前对话包含视频，仅支持 Qwen3.5 或 Kimi-k2.5")
|
||
self.model_key = model_key
|
||
self.model_profile = profile
|
||
# 将模型标识传递给底层 API 客户端，便于按模型做兼容处理
|
||
self.api_client.model_key = model_key
|
||
# 应用模型配置
|
||
self.apply_model_profile(profile)
|
||
# fast-only 模型强制快速模式
|
||
if profile.get("fast_only") and self.run_mode != "fast":
|
||
self.set_run_mode("fast")
|
||
# 仅深度思考模型强制 deep
|
||
if profile.get("deep_only") and self.run_mode != "deep":
|
||
self.set_run_mode("deep")
|
||
# 如果模型支持思考，但当前 run_mode 为 thinking/deep，则保持；否则无需调整
|
||
self.api_client.start_new_task(force_deep=self.deep_thinking_mode)
|
||
return self.model_key
|
||
|
||
def get_run_mode_label(self) -> str:
|
||
labels = {
|
||
"fast": "快速模式（无思考）",
|
||
"thinking": "思考模式（首次调用使用思考模型）",
|
||
"deep": "深度思考模式（整轮使用思考模型）"
|
||
}
|
||
return labels.get(self.run_mode, "快速模式（无思考）")
|
||
|
||
async def toggle_mode(self, args: str = ""):
|
||
"""切换运行模式"""
|
||
modes = ["fast", "thinking", "deep"]
|
||
target_mode = ""
|
||
if args:
|
||
candidate = args.strip().lower()
|
||
if candidate not in modes:
|
||
print(f"{OUTPUT_FORMATS['error']} 无效模式: {args}。可选: fast / thinking / deep")
|
||
return
|
||
target_mode = candidate
|
||
else:
|
||
current_index = modes.index(self.run_mode) if self.run_mode in modes else 0
|
||
target_mode = modes[(current_index + 1) % len(modes)]
|
||
if target_mode == self.run_mode:
|
||
print(f"{OUTPUT_FORMATS['info']} 当前已是 {self.get_run_mode_label()}")
|
||
return
|
||
try:
|
||
self.set_run_mode(target_mode)
|
||
print(f"{OUTPUT_FORMATS['info']} 已切换到: {self.get_run_mode_label()}")
|
||
except ValueError as exc:
|
||
print(f"{OUTPUT_FORMATS['error']} {exc}")
|