vox-code 2.0.0__py3-none-any.whl

voxcli/memory/manager.py

@@ -0,0 +1,101 @@
+"""Memory 管理器 - Memory 系统的门面类"""
+
+import uuid
+from typing import List, Optional
+
+from ..llm.base import LlmClient
+from .entry import MemoryEntry, MemoryType, estimate_tokens
+from .short_term import ConversationMemory
+from .long_term import LongTermMemory
+from .retriever import MemoryRetriever
+from .budget import TokenBudget
+from .compressor import ContextCompressor
+
+
+_MAX_TOOL_RESULT_CHARS = 500
+
+
+class MemoryManager:
+    def __init__(self, llm_client: LlmClient,
+                 short_term_budget: int = 32768,
+                 context_window: int = 200000,
+                 long_term: Optional[LongTermMemory] = None):
+        self._short_term = ConversationMemory(short_term_budget)
+        self._long_term = long_term or LongTermMemory()
+        self._compressor = ContextCompressor(llm_client)
+        self._retriever = MemoryRetriever(self._short_term, self._long_term)
+        self._budget = TokenBudget(context_window)
+        self._llm = llm_client
+
+    def set_llm_client(self, llm_client: LlmClient):
+        self._llm = llm_client
+        self._compressor.set_llm_client(llm_client)
+
+    def add_user_message(self, content: str):
+        entry = MemoryEntry(
+            id=f"user-{uuid.uuid4().hex[:8]}",
+            content=content,
+            type=MemoryType.CONVERSATION,
+            metadata={"source": "user"},
+        )
+        self._short_term.store(entry)
+        self._compress_if_needed()
+
+    def add_assistant_message(self, content: str):
+        entry = MemoryEntry(
+            id=f"assistant-{uuid.uuid4().hex[:8]}",
+            content=content,
+            type=MemoryType.CONVERSATION,
+            metadata={"source": "assistant"},
+        )
+        self._short_term.store(entry)
+        self._compress_if_needed()
+
+    def add_tool_result(self, tool_name: str, result: str):
+        truncated = result[:_MAX_TOOL_RESULT_CHARS] + "...(已截断)" if len(result) > _MAX_TOOL_RESULT_CHARS else result
+        content = f"[{tool_name}] {truncated}"
+        entry = MemoryEntry(
+            id=f"tool-{uuid.uuid4().hex[:8]}",
+            content=content,
+            type=MemoryType.TOOL_RESULT,
+            metadata={"source": "tool", "toolName": tool_name},
+        )
+        self._short_term.store(entry)
+        self._compress_if_needed()
+
+    def store_fact(self, fact: str):
+        entry = MemoryEntry(
+            id=f"fact-{uuid.uuid4().hex[:8]}",
+            content=fact,
+            type=MemoryType.FACT,
+            metadata={"source": "fact"},
+        )
+        self._long_term.store(entry)
+
+    def retrieve_relevant(self, query: str, limit: int) -> List[MemoryEntry]:
+        return self._retriever.retrieve(query, limit)
+
+    def build_context_for_query(self, query: str, max_tokens: int) -> str:
+        return self._retriever.build_context_for_query(query, max_tokens)
+
+    def record_token_usage(self, input_tokens: int, output_tokens: int):
+        self._budget.record_usage(input_tokens, output_tokens)
+
+    def clear_short_term(self):
+        self._short_term.clear()
+
+    def clear_long_term(self):
+        self._long_term.clear()
+
+    def status_summary(self) -> str:
+        return (f"{self._short_term.status_summary()}\n"
+                f"{self._long_term.status_summary()}\n"
+                f"{self._budget.usage_report}")
+
+    def _compress_if_needed(self):
+        if not self._budget.needs_compression(self._short_term):
+            return
+        print("📦 短期记忆接近预算上限，触发压缩...")
+        summary = self._compressor.compress(self._short_term)
+        if summary:
+            print(f"   压缩完成，摘要: {summary[:100]}...")

voxcli/memory/retriever.py

@@ -0,0 +1,72 @@
+"""记忆检索器"""
+
+import time
+from typing import List
+
+from .entry import MemoryEntry, MemoryType
+from .long_term import LongTermMemory
+from .short_term import ConversationMemory
+from .tokenizer import tokenize
+
+
+class MemoryRetriever:
+    def __init__(self, short_term: ConversationMemory, long_term: LongTermMemory):
+        self._short_term = short_term
+        self._long_term = long_term
+
+    def retrieve(self, query: str, limit: int) -> List[MemoryEntry]:
+        scored: list[tuple[MemoryEntry, float]] = []
+        for entry in self._short_term.get_all():
+            score = self._compute_relevance(entry, query)
+            if score > 0:
+                scored.append((entry, score))
+        for entry in self._long_term.get_all():
+            score = self._compute_relevance(entry, query) * 1.2
+            if score > 0:
+                scored.append((entry, score))
+        scored.sort(key=lambda x: x[1], reverse=True)
+        return [e for e, _ in scored[:limit]]
+
+    def retrieve_long_term(self, query: str, limit: int) -> List[MemoryEntry]:
+        scored: list[tuple[MemoryEntry, float]] = []
+        for entry in self._long_term.get_all():
+            score = self._compute_relevance(entry, query) * 1.2
+            if score > 0:
+                scored.append((entry, score))
+        scored.sort(key=lambda x: x[1], reverse=True)
+        return [e for e, _ in scored[:limit]]
+
+    def build_context_for_query(self, query: str, max_tokens: int) -> str:
+        relevant = self.retrieve_long_term(query, 10)
+        if not relevant:
+            return ""
+        parts = ["## 相关长期记忆\n"]
+        used = 0
+        for entry in relevant:
+            if used + entry.token_count > max_tokens:
+                break
+            parts.append(f"- [{entry.type.value}] {entry.content}\n")
+            used += entry.token_count
+        parts.append("\n")
+        return "".join(parts)
+
+    @staticmethod
+    def _compute_relevance(entry: MemoryEntry, query: str) -> float:
+        content_lower = entry.content.lower()
+        query_lower = query.lower()
+
+        if query_lower in content_lower:
+            return 1.0
+
+        query_words = tokenize(query_lower)
+        if not query_words:
+            return 0.0
+
+        matched = sum(1 for w in query_words if w in content_lower)
+        if matched == 0:
+            return 0.0
+
+        keyword_score = matched / len(query_words)
+        age_hours = (time.time() - entry.timestamp) / 3600
+        time_decay = max(0.5, 1.0 - age_hours / 24.0)
+        return keyword_score * time_decay

voxcli/memory/short_term.py

@@ -0,0 +1,84 @@
+"""短期记忆 - 管理当前对话上下文"""
+
+from collections import OrderedDict
+from typing import List, Optional
+
+from .base import Memory
+from .entry import MemoryEntry
+from .tokenizer import matches, tokenize
+
+
+class ConversationMemory(Memory):
+    def __init__(self, max_tokens: int = 32768):
+        self._entries: OrderedDict[str, MemoryEntry] = OrderedDict()
+        self._max_tokens = max_tokens
+        self._current_tokens = 0
+        self._compressed_summaries: List[MemoryEntry] = []
+
+    def store(self, entry: MemoryEntry):
+        self._entries[entry.id] = entry
+        self._current_tokens += entry.token_count
+        while self._current_tokens > self._max_tokens and len(self._entries) > 1:
+            self._evict_oldest()
+
+    def retrieve(self, id: str) -> Optional[MemoryEntry]:
+        return self._entries.get(id)
+
+    def search(self, query: str, limit: int) -> List[MemoryEntry]:
+        query_tokens = tokenize(query)
+        results = []
+        for entry in self._entries.values():
+            if matches(entry.content, query_tokens):
+                results.append(entry)
+                if len(results) >= limit:
+                    break
+        return results
+
+    def get_all(self) -> List[MemoryEntry]:
+        return list(self._entries.values())
+
+    def delete(self, id: str) -> bool:
+        entry = self._entries.pop(id, None)
+        if entry:
+            self._current_tokens -= entry.token_count
+            return True
+        return False
+
+    def clear(self):
+        self._entries.clear()
+        self._current_tokens = 0
+        self._compressed_summaries.clear()
+
+    def token_count(self) -> int:
+        return self._current_tokens
+
+    def size(self) -> int:
+        return len(self._entries)
+
+    @property
+    def max_tokens(self) -> int:
+        return self._max_tokens
+
+    def get_compressed_summaries(self) -> List[MemoryEntry]:
+        return list(self._compressed_summaries)
+
+    def inject_summary(self, summary: MemoryEntry):
+        self._compressed_summaries.clear()
+        self._entries[summary.id] = summary
+        self._current_tokens += summary.token_count
+
+    @property
+    def usage_ratio(self) -> float:
+        return self._current_tokens / self._max_tokens if self._max_tokens > 0 else 0.0
+
+    def status_summary(self) -> str:
+        return (f"短期记忆: {self.size()}条 / {self._current_tokens} tokens "
+                f"(预算: {self._max_tokens}, 使用率: {self.usage_ratio * 100:.0f}%, "
+                f"已压缩: {len(self._compressed_summaries)}条)")
+
+    def _evict_oldest(self):
+        if not self._entries:
+            return
+        _id, entry = self._entries.popitem(last=False)
+        self._current_tokens -= entry.token_count
+        self._compressed_summaries.append(entry)

voxcli/memory/tokenizer.py

@@ -0,0 +1,21 @@
+"""记忆查询关键词分词"""
+
+import re
+from typing import Set
+
+
+def tokenize(text: str) -> Set[str]:
+    if not text:
+        return set()
+    text = text.lower()
+    # 按非字母数字字符分割
+    tokens = set(re.findall(r'[a-zA-Z0-9一-鿿]+', text))
+    # 去掉单字词（无意义）
+    return {t for t in tokens if len(t) > 1 if not t.isascii() or len(t) > 2}
+
+
+def matches(content: str, query_tokens: Set[str]) -> bool:
+    if not query_tokens:
+        return True
+    content_lower = content.lower()
+    return any(t in content_lower for t in query_tokens)

voxcli/plan/__init__.py

@@ -0,0 +1,5 @@
+from .task import Task, TaskType, TaskStatus
+from .execution_plan import ExecutionPlan, PlanStatus
+from .planner import Planner
+
+__all__ = ["Task", "TaskType", "TaskStatus", "ExecutionPlan", "PlanStatus", "Planner"]

voxcli/plan/execution_plan.py

@@ -0,0 +1,225 @@
+"""执行计划 - 包含一组有依赖关系的任务"""
+
+import time
+from enum import Enum
+from typing import List, Optional, Dict, Set
+from collections import OrderedDict
+
+from .task import Task, TaskStatus
+
+
+class PlanStatus(Enum):
+    CREATED = "CREATED"
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    CANCELLED = "CANCELLED"
+
+
+class ExecutionPlan:
+    def __init__(self, id: str, goal: str):
+        self._id = id
+        self._goal = goal
+        self._tasks: Dict[str, Task] = OrderedDict()
+        self._execution_order: List[str] = []
+        self._status = PlanStatus.CREATED
+        self._summary: Optional[str] = None
+        self._start_time: float = 0.0
+        self._end_time: float = 0.0
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def goal(self) -> str:
+        return self._goal
+
+    @property
+    def status(self) -> PlanStatus:
+        return self._status
+
+    @property
+    def summary(self) -> Optional[str]:
+        return self._summary
+
+    @summary.setter
+    def summary(self, value: str):
+        self._summary = value
+
+    @property
+    def start_time(self) -> float:
+        return self._start_time
+
+    @property
+    def end_time(self) -> float:
+        return self._end_time
+
+    def add_task(self, task: Task):
+        self._tasks[task.id] = task
+        for dep_id in task.dependencies:
+            dep = self._tasks.get(dep_id)
+            if dep is not None:
+                dep.add_dependent(task.id)
+
+    def get_task(self, id: str) -> Optional[Task]:
+        return self._tasks.get(id)
+
+    def get_all_tasks(self) -> List[Task]:
+        return list(self._tasks.values())
+
+    def get_root_tasks(self) -> List[Task]:
+        return [t for t in self._tasks.values() if not t.dependencies]
+
+    def get_executable_tasks(self) -> List[Task]:
+        return [t for t in self._tasks.values() if t.is_executable(self._tasks)]
+
+    def compute_execution_order(self) -> bool:
+        self._execution_order.clear()
+        visited: Set[str] = set()
+        visiting: Set[str] = set()
+
+        def topo_sort(task: Task) -> bool:
+            if task.id in visiting:
+                return False
+            if task.id in visited:
+                return True
+            visiting.add(task.id)
+            for dep_id in task.dependencies:
+                dep = self._tasks.get(dep_id)
+                if dep is not None:
+                    if not topo_sort(dep):
+                        return False
+            visiting.remove(task.id)
+            visited.add(task.id)
+            self._execution_order.append(task.id)
+            return True
+
+        for task in self._tasks.values():
+            if task.id not in visited:
+                if not topo_sort(task):
+                    return False
+        return True
+
+    def get_execution_order(self) -> List[str]:
+        if not self._execution_order:
+            self.compute_execution_order()
+        return list(self._execution_order)
+
+    def get_progress(self) -> float:
+        if not self._tasks:
+            return 1.0
+        completed = sum(1 for t in self._tasks.values()
+                        if t.status == TaskStatus.COMPLETED)
+        return completed / len(self._tasks)
+
+    def is_all_completed(self) -> bool:
+        return all(t.status == TaskStatus.COMPLETED
+                   for t in self._tasks.values())
+
+    def has_failed(self) -> bool:
+        return any(t.status == TaskStatus.FAILED
+                   for t in self._tasks.values())
+
+    def mark_started(self):
+        self._status = PlanStatus.RUNNING
+        self._start_time = time.time()
+
+    def mark_completed(self):
+        self._status = PlanStatus.COMPLETED
+        self._end_time = time.time()
+
+    def mark_failed(self):
+        self._status = PlanStatus.FAILED
+        self._end_time = time.time()
+
+    def mark_cancelled(self):
+        self._status = PlanStatus.CANCELLED
+        self._end_time = time.time()
+
+    @property
+    def duration(self) -> float:
+        if self._start_time == 0:
+            return 0.0
+        if self._end_time == 0:
+            return time.time() - self._start_time
+        return self._end_time - self._start_time
+
+    def visualize(self) -> str:
+        lines = []
+        lines.append("╔══════════════════════════════════════════════════════════╗")
+        goal_display = self._goal[:46] + "..." if len(self._goal) > 46 else self._goal
+        lines.append(f"║  执行计划: {goal_display:<46}║")
+        lines.append("╠══════════════════════════════════════════════════════════╣")
+
+        order = self.get_execution_order()
+        for i, task_id in enumerate(order):
+            task = self._tasks[task_id]
+            icon = self._status_icon(task.status)
+            deps = ",".join(task.dependencies) if task.dependencies else "无"
+            lines.append(f"║  {i+1}. {icon} {task._id:<20} [{task.type.value:<10}] 依赖: {deps:<15}║")
+            desc = task.description[:47] + "..." if len(task.description) > 50 else task.description
+            lines.append(f"║     {desc:<53}║")
+
+        lines.append("╚══════════════════════════════════════════════════════════╝")
+        lines.append(f"   进度: {self.get_progress()*100:.0f}% | 状态: {self._status.value}")
+        return "\n".join(lines)
+
+    def summarize(self) -> str:
+        batches = self.get_execution_batches()
+        ready = self.get_executable_tasks()
+        lines = ["📋 计划摘要",
+                 f"   - 目标: {self._compact_goal(48)}",
+                 f"   - 任务数: {len(self._tasks)} | 并行批次: {len(batches)} | "
+                 f"当前可执行: {len(ready)} | 状态: {self._status.value}"]
+        if batches:
+            lines.append(f"   - 首批执行: {self._format_task_list(batches[0], 5)}")
+            if len(batches) > 1:
+                lines.append(f"   - 最终收敛: {self._format_task_list(batches[-1], 5)}")
+        return "\n".join(lines)
+
+    def get_execution_batches(self) -> List[List[Task]]:
+        if not self._tasks:
+            return []
+        remaining = OrderedDict(self._tasks)
+        completed: Set[str] = set()
+        batches = []
+        while remaining:
+            batch = [t for t in remaining.values()
+                     if completed.issuperset(t.dependencies)]
+            if not batch:
+                break
+            batches.append(batch)
+            for t in batch:
+                remaining.pop(t.id)
+                completed.add(t.id)
+        return batches
+
+    def _compact_goal(self, max_length: int) -> str:
+        goal = self._goal.replace("\r\n", " ").replace("\r", " ").replace("\n", " ").strip()
+        import re
+        goal = re.sub(r" {2,}", " ", goal)
+        if len(goal) <= max_length:
+            return goal
+        return goal[:max_length - 3] + "..."
+
+    def _format_task_list(self, batch: List[Task], limit: int) -> str:
+        if not batch:
+            return "无"
+        ids = [t.id for t in batch]
+        if len(ids) <= limit:
+            return ", ".join(ids)
+        return ", ".join(ids[:limit]) + f" 等 {len(ids)} 个任务"
+
+    @staticmethod
+    def _status_icon(status: TaskStatus) -> str:
+        return {
+            TaskStatus.PENDING: "⏳",
+            TaskStatus.RUNNING: "▶️",
+            TaskStatus.COMPLETED: "✅",
+            TaskStatus.FAILED: "❌",
+            TaskStatus.SKIPPED: "⏭️",
+        }.get(status, "⏳")
+
+    def __repr__(self) -> str:
+        return f"ExecutionPlan[{self._id}: {self._goal}] ({len(self._tasks)} tasks, {self._status.value})"