import os
import time
import logging
# 使用绝对导入
from core.config import system_config
from core.environment import DefaultEnvironment, AIHome, ActionExecutor # 修改导入为具体实现类
class AutonomousAgent:
def __init__(self):
self.logger = self._setup_logger()
self.logger.info("🔁 初始化自主智能体核心模块...")
try:
# 初始化环境感知系统 - 修复部分
self._initialize_environment_systems()
# 初始化各子系统
self._initialize_subsystems()
self.logger.info("✅ 自主智能体初始化完成")
except Exception as e:
self.logger.error(f"❌ 智能体初始化失败: {str(e)}")
raise
def _setup_logger(self):
"""配置日志记录器"""
logger = logging.getLogger('AutonomousAgent')
logger.setLevel(system_config.LOG_LEVEL)
# 创建控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(system_config.LOG_LEVEL)
# 创建格式化器
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
# 添加处理器
logger.addHandler(console_handler)
logger.propagate = False
return logger
def _initialize_environment_systems(self):
"""初始化环境感知系统 - 修复后"""
# 获取项目根目录
base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 修复：使用具体实现类 DefaultEnvironment
self.environment = DefaultEnvironment(base_dir) # 传递 base_dir
self.logger.info("✅ 环境接口初始化完成")
# 初始化智能家居环境
self.home = AIHome(base_dir)
self.logger.info("✅ 智能家居环境初始化完成")
# 修复：ActionExecutor 不需要参数
self.executor = ActionExecutor() # 移除环境参数
self.logger.info("✅ 动作执行器初始化完成")
# 记录环境状态
env_status = self.environment.get_system_info()
self.logger.info(f"📊 系统状态: OS={env_status['os']}, CPU={env_status['cpu']}, "
f"内存={env_status['memory']}GB, 磁盘={env_status['disk_usage']}%")
def _initialize_subsystems(self):
"""初始化所有子系统"""
# 1. 初始化模型管理器
from .model_manager import ModelManager
self.model_manager = ModelManager(
model_dir=system_config.MODEL_DIR,
device=system_config.DEVICE,
default_model=system_config.DEFAULT_MODEL
)
self.logger.info("✅ 模型管理器初始化完成")
# 2. 初始化健康系统
from .health_system import HealthSystem
self.health_system = HealthSystem(self)
self.logger.info("✅ 健康系统初始化完成")
# 3. 初始化记忆系统
from .memory_system import MemorySystem
self.memory_system = MemorySystem(self)
self.logger.info("✅ 记忆系统初始化完成")
# 4. 初始化情感系统
from .affective_system import AffectiveSystem
self.affective_system = AffectiveSystem(agent=self)
self.logger.info("✅ 情感系统初始化完成")
# 5. 初始化认知架构
from .cognitive_architecture import CognitiveArchitecture
self.cognitive_architecture = CognitiveArchitecture(agent=self)
self.logger.info("✅ 认知架构初始化完成")
# 6. 初始化通信系统
from .communication_system import CommunicationSystem
self.communication_system = CommunicationSystem(
cognitive_system=self.cognitive_architecture,
agent=self # 传递智能体实例
)
self.logger.info("✅ 通信系统初始化完成")
def process_input(self, user_input, user_id="default"):
"""处理用户输入（通过通信系统）"""
return self.communication_system.process_input(user_input, user_id)
def run_periodic_tasks(self):
"""运行周期性任务"""
# 更新健康状态
self.health_system.update()
# 情感系统更新
self.affective_system.grow()
# 记忆系统维护
self.memory_system.consolidate_memories()
# 修复：环境状态监控 - 使用时间戳
current_time = time.time()
if not hasattr(self, "_last_env_check"):
self._last_env_check = current_time
# 每5分钟检查一次
if current_time - self._last_env_check > 300:
self._last_env_check = current_time
self._monitor_environment()
def _monitor_environment(self):
"""监控环境状态 - 修复后"""
try:
# 获取当前系统状态
env_status = self.environment.get_system_info()
# 安全解析磁盘使用率
disk_str = env_status.get('disk_usage', '0%').strip()
if disk_str.endswith('%'):
try:
disk_usage = float(disk_str[:-1])
except ValueError:
disk_usage = 0.0
else:
disk_usage = 0.0
if disk_usage > 90:
self.logger.warning(f"⚠️ 磁盘空间不足！当前使用率: {disk_usage}%")
# 安全解析内存使用
memory_str = env_status.get('memory', '0GB/0GB')
try:
# 支持多种格式: "3.2GB/16GB" 或 "3.2/16.0 GB"
parts = memory_str.replace('GB', '').replace(' ', '').split('/')
if len(parts) >= 2:
memory_used = float(parts[0])
memory_total = float(parts[1])
memory_ratio = memory_used / memory_total
if memory_ratio > 0.85:
self.logger.warning(
f"⚠️ 内存使用过高！已用: {memory_used:.1f}GB, "
f"总共: {memory_total:.1f}GB, "
f"使用率: {memory_ratio * 100:.1f}%"
)
except (ValueError, TypeError, ZeroDivisionError) as e:
self.logger.error(f"内存数据解析失败: {memory_str} - {str(e)}")
# 记录到健康系统
self.health_system.record_environment_status(env_status)
except Exception as e:
self.logger.error(f"环境监控失败: {str(e)}", exc_info=True)
def get_status(self):
"""获取智能体状态报告"""
# 获取基础状态
status = {
"health": self.health_system.get_status(),
"affective": self.affective_system.get_state(),
"memory_stats": self.memory_system.get_stats(),
"model": self.model_manager.get_current_model_info()
}
# 添加环境信息
try:
env_status = self.environment.get_system_info()
status["environment"] = {
"os": env_status.get("os", "未知"),
"cpu": env_status.get("cpu", "0%"),
"memory": env_status.get("memory", "0GB/0GB"),
"disk": env_status.get("disk_usage", "0%")
}
except Exception as e:
status["environment"] = {"error": str(e)}
return status
# 环境交互方法
def explore_environment(self, path=None):
"""探索环境目录"""
try:
return self.environment.explore_directory(path)
except Exception as e:
self.logger.error(f"环境探索失败: {str(e)}")
return {"error": str(e)}
def execute_action(self, action, parameters):
"""通过执行器执行动作"""
try:
result = self.executor.execute(action, parameters)
self.logger.info(f"执行动作: {action} {parameters} → {result.get('status', '未知')}")
return result
except Exception as e:
self.logger.error(f"动作执行失败: {action} {parameters} - {str(e)}")
return {"status": "error", "message": str(e)}
import os
import psutil
import platform
import json
import sqlite3
import sys
import subprocess
import requests
import logging
from datetime import datetime
# 修复快捷方式解析问题
def resolve_shortcut(path):
"""解析快捷方式路径（简化实现）"""
if sys.platform == 'win32':
if path.endswith('.lnk'):
# Windows 系统下解析 .lnk 文件
try:
import win32com.client
shell = win32com.client.Dispatch("WScript.Shell")
shortcut = shell.CreateShortCut(path)
return shortcut.Targetpath
except ImportError:
# 如果没有 win32com 模块，直接返回路径
return path
# 非 Windows 系统或非快捷文件直接返回
return path
class EnvironmentInterface:
def __init__(self):
# 配置日志
self.logger = logging.getLogger('EnvironmentInterface')
self.logger.setLevel(logging.INFO)
console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
self.logger.addHandler(console_handler)
# 工作区路径设置
self.workspace_root = "E:\\AI_Workspace"
# 解析路径并确保目录存在
self.models_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "01_模型存储", "主模型.lnk"))
self.cache_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "01_模型存储", "下载缓存.lnk"))
self.system_dir = self._resolve_and_create_dir(
os.path.join(self.workspace_root, "02_核心代码", "Agent系统.lnk"))
self.temp_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "04_环境工具", "临时补丁.lnk"))
self.python_dir = self._resolve_and_create_dir(
os.path.join(self.workspace_root, "04_环境工具", "Python环境.lnk"))
# 环境配置
os.environ['PATH'] = f"{self.python_dir};{self.python_dir}\\Scripts;{os.environ['PATH']}"
os.environ['HF_HOME'] = self.cache_dir
# 安全策略
self.authorized_actions = {
"file_access": True,
"web_search": True,
"command_exec": True,
"software_install": False,
"hardware_control": False
}
self.action_log = []
# 初始化数据库
self.environment_db = os.path.join(self.system_dir, 'environment.db')
self._init_db()
self.logger.info("环境接口初始化完成")
def _resolve_and_create_dir(self, path):
"""解析路径并确保目录存在"""
resolved = resolve_shortcut(path)
# 如果是文件路径，获取其目录
if os.path.isfile(resolved):
dir_path = os.path.dirname(resolved)
else:
dir_path = resolved
# 创建目录（如果不存在）
if not os.path.exists(dir_path):
os.makedirs(dir_path, exist_ok=True)
self.logger.info(f"创建目录: {dir_path}")
return resolved
def _init_db(self):
"""初始化环境数据库"""
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
# 系统信息表
c.execute('''CREATE TABLE IF NOT EXISTS system_info (
id INTEGER PRIMARY KEY,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
os TEXT,
cpu TEXT,
memory REAL,
disk_usage REAL
)''')
# 文件探索历史表
c.execute('''CREATE TABLE IF NOT EXISTS file_exploration (
id INTEGER PRIMARY KEY,
path TEXT UNIQUE,
last_visited DATETIME,
visit_count INTEGER DEFAULT 0
)''')
# 资源管理表
c.execute('''CREATE TABLE IF NOT EXISTS resources (
id INTEGER PRIMARY KEY,
name TEXT,
type TEXT, -- skin, furniture, tool
path TEXT,
is_active BOOLEAN DEFAULT 0
)''')
conn.commit()
conn.close()
self.logger.info(f"数据库初始化完成: {self.environment_db}")
# 系统监控功能
def get_system_info(self):
"""获取并记录系统信息"""
try:
# 获取内存使用情况
mem = psutil.virtual_memory()
mem_used = round(mem.used / (1024 ** 3), 1)
mem_total = round(mem.total / (1024 ** 3), 1)
# 获取磁盘使用情况
disk_usage = psutil.disk_usage('/').percent
info = {
"os": f"{platform.system()} {platform.release()}",
"cpu": f"{platform.processor()} ({psutil.cpu_count(logical=False)} cores)",
"memory": f"{mem_used}GB/{mem_total}GB",
"disk_usage": f"{disk_usage}%"
}
# 保存到数据库
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute('''INSERT INTO system_info
(os, cpu, memory, disk_usage)
VALUES (?, ?, ?, ?)''',
(info['os'], info['cpu'], mem_used, disk_usage))
conn.commit()
conn.close()
self.log_action("system_monitor", "采集系统信息")
return info
except Exception as e:
self.logger.error(f"获取系统信息失败: {str(e)}")
return {
"os": f"Error: {str(e)}",
"cpu": "0%",
"memory": "0GB/0GB",
"disk_usage": "0%"
}
# 文件探索功能
def explore_directory(self, path=None):
"""探索目录内容"""
try:
target_path = path or self.workspace_root
target_path = os.path.abspath(target_path)
# 安全路径检查
if not target_path.startswith(os.path.abspath(self.workspace_root)):
return {"error": "访问路径超出工作区范围"}
if not os.path.exists(target_path):
return {"error": "路径不存在"}
# 记录探索历史
self._record_exploration(target_path)
contents = []
for item in os.listdir(target_path):
full_path = os.path.join(target_path, item)
try:
is_dir = os.path.isdir(full_path)
size = os.path.getsize(full_path) if not is_dir else 0
modified_time = os.path.getmtime(full_path)
contents.append({
"name": item,
"type": "directory" if is_dir else "file",
"path": full_path,
"size": f"{size / 1024:.1f}KB" if size < 1024 ** 2 else f"{size / (1024 ** 2):.1f}MB",
"modified": datetime.fromtimestamp(modified_time).strftime("%Y-%m-%d %H:%M")
})
except PermissionError:
contents.append({
"name": item,
"type": "unknown",
"error": "权限不足"
})
except Exception as e:
contents.append({
"name": item,
"type": "unknown",
"error": str(e)
})
self.log_action("file_explore", f"探索路径: {target_path}")
return {
"current_path": target_path,
"contents": sorted(contents, key=lambda x: (x['type'] == 'directory', x['name']), reverse=True)
}
except Exception as e:
self.logger.error(f"探索目录失败: {str(e)}")
return {"error": str(e)}
def _record_exploration(self, path):
"""记录探索历史到数据库"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute("SELECT id FROM file_exploration WHERE path = ?", (path,))
if c.fetchone():
c.execute('''UPDATE file_exploration
SET last_visited = CURRENT_TIMESTAMP,
visit_count = visit_count + 1
WHERE path = ?''', (path,))
else:
c.execute('''INSERT INTO file_exploration
(path, last_visited, visit_count)
VALUES (?, CURRENT_TIMESTAMP, 1)''', (path,))
conn.commit()
except Exception as e:
self.logger.error(f"记录探索历史失败: {str(e)}")
finally:
conn.close()
def get_exploration_history(self):
"""获取探索历史记录"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute('''SELECT path, last_visited, visit_count
FROM file_exploration
ORDER BY last_visited DESC
LIMIT 10''')
history = [
{"path": item[0],
"last_visited": item[1],
"visit_count": item[2]}
for item in c.fetchall()
]
return history
except Exception as e:
self.logger.error(f"获取探索历史失败: {str(e)}")
return []
finally:
conn.close()
# 资源管理功能
def get_resource(self, resource_type):
"""获取特定类型资源"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute('''SELECT name, path, is_active
FROM resources
WHERE type = ?''', (resource_type,))
resources = [
{"name": item[0], "path": item[1], "is_active": bool(item[2])}
for item in c.fetchall()
]
return resources
except Exception as e:
self.logger.error(f"获取资源失败: {str(e)}")
return []
finally:
conn.close()
def activate_resource(self, resource_name):
"""激活特定资源"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute('''UPDATE resources
SET is_active = 0
WHERE type = (SELECT type FROM resources WHERE name = ?)''',
(resource_name,))
c.execute('''UPDATE resources
SET is_active = 1
WHERE name = ?''', (resource_name,))
conn.commit()
self.log_action("resource_activate", f"激活资源: {resource_name}")
return True
except Exception as e:
self.logger.error(f"激活资源失败: {str(e)}")
return False
finally:
conn.close()
# 工作区管理功能
def get_workspace_info(self):
"""获取工作区信息"""
return {
"workspace": self.workspace_root,
"models": self.models_dir,
"system": self.system_dir,
"cache": self.cache_dir,
"temp": self.temp_dir,
"python": self.python_dir
}
# 命令执行功能
def execute_command(self, command):
"""执行经过授权的系统命令"""
if not self._is_authorized("command_exec"):
return {"error": "命令执行未授权"}
try:
result = subprocess.run(
command,
shell=True,
capture_output=True,
text=True,
cwd=self.system_dir,
timeout=30 # 防止长时间运行
)
output = {
"success": result.returncode == 0,
"returncode": result.returncode,
"stdout": result.stdout,
"stderr": result.stderr
}
self.log_action("command_exec", f"命令: {command[:50]}... 结果: {output['success']}")
return output
except subprocess.TimeoutExpired:
return {"error": "命令执行超时"}
except Exception as e:
return {"error": str(e)}
# 网络搜索功能
def web_search(self, query):
"""安全网络搜索"""
if not self._is_authorized("web_search"):
return {"error": "网络搜索未授权"}
try:
# 使用安全的搜索引擎
response = requests.get(
f"https://search.brave.com/search?q={requests.utils.quote(query)}",
headers={
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
},
timeout=10
)
# 简化结果解析
results = []
# 注意：实际实现需要根据搜索引擎的HTML结构解析
# 这里只是一个示例
results.append({
"title": "示例结果 1",
"url": "https://example.com/result1",
"content": "这是关于查询的第一个结果..."
})
results.append({
"title": "示例结果 2",
"url": "https://example.com/result2",
"content": "这是关于查询的第二个结果..."
})
self.log_action("web_search", f"查询: {query[:30]}... 结果数: {len(results)}")
return {"success": True, "results": results}
except Exception as e:
return {"error": str(e)}
# 文件操作功能
def read_file(self, file_path):
"""读取工作区文件"""
full_path = os.path.join(self.workspace_root, file_path)
if not self._is_authorized("file_access"):
return {"error": "文件访问未授权"}
if not os.path.abspath(full_path).startswith(os.path.abspath(self.workspace_root)):
return {"error": "访问路径超出工作区范围"}
try:
with open(full_path, 'r', encoding='utf-8') as f:
content = f.read()
self.log_action("file_read", f"读取文件: {file_path}")
return content
except Exception as e:
return {"error": str(e)}
def write_file(self, file_path, content):
"""写入工作区文件"""
full_path = os.path.join(self.workspace_root, file_path)
if not self._is_authorized("file_access"):
return {"error": "文件访问未授权"}
if not os.path.abspath(full_path).startswith(os.path.abspath(self.workspace_root)):
return {"error": "访问路径超出工作区范围"}
try:
os.makedirs(os.path.dirname(full_path), exist_ok=True)
with open(full_path, 'w', encoding='utf-8') as f:
f.write(content)
self.log_action("file_write", f"写入文件: {file_path} ({len(content)} 字节)")
return "文件写入成功"
except Exception as e:
return {"error": str(e)}
# 辅助功能
def _is_authorized(self, action):
"""检查操作授权状态"""
return self.authorized_actions.get(action, False)
def log_action(self, action, details):
"""记录环境操作日志"""
log_entry = {
"timestamp": datetime.now().isoformat(),
"action": action,
"details": details
}
self.action_log.append(log_entry)
# 保存到文件
log_file = os.path.join(self.workspace_root, "environment_actions.log")
try:
with open(log_file, 'a', encoding='utf-8') as f:
f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
except Exception as e:
self.logger.error(f"记录日志失败: {str(e)}")
# 同时记录到logger
self.logger.info(f"{action}: {details}")
return True
# 使用示例
if __name__ == "__main__":
# 配置日志
logging.basicConfig(level=logging.INFO)
env = EnvironmentInterface()
# 获取工作区信息
print("工作区信息:", json.dumps(env.get_workspace_info(), indent=2, ensure_ascii=False))
# 获取系统信息
print("系统信息:", json.dumps(env.get_system_info(), indent=2, ensure_ascii=False))
# 探索目录
print("工作区内容:", json.dumps(env.explore_directory(), indent=2, ensure_ascii=False))
# 执行命令
print("命令结果:", json.dumps(env.execute_command("echo Hello World"), indent=2, ensure_ascii=False))
# 文件操作
test_file = "test_env_interface.txt"
result = env.write_file(test_file, "环境接口测试内容")
print("文件写入结果:", result)
content = env.read_file(test_file)
print("文件内容:", content)
两个文件都给你 你看看怎么改
最新发布
本文详细介绍了HTML中的相对路径和绝对路径的使用方法，包括同一目录、上级目录及下级目录文件的引用方式，帮助读者理解并正确应用不同路径。
扫一扫
1613
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
