ufy-auc 0.2.4__py3-none-any.whl

auc/__init__.py

@@ -0,0 +1,125 @@
+"""Agents-ufy-Core (AuC): asyncio single-agent framework."""
+
+from auc.agent import AgentConfig, DefaultAgent
+from auc.checkpoint import CheckpointStore
+from auc.config import (
+    ModelConfig,
+    default_config_path,
+    discover_config_path,
+    load_model_config,
+    user_config_dir,
+)
+from auc.context import ListContextWindow
+from auc.events import EventBus, RunEvent
+from auc.loop import AgentLoopRunner, LoopConfig, ReActLoop
+from auc.messages import ChatMessage, RunRequest, RunResult, ToolCall, ToolResult
+from auc.model import AssistantMessage, InMemoryModelClient
+from auc.ports import (
+    AutoApprovePort,
+    CodeSnippet,
+    ContextPackage,
+    DefaultComposer,
+    DenyApprovalPort,
+    FileRulesPort,
+    InMemoryMemoryPort,
+    NoOpMemoryPort,
+    SlicerPolicy,
+)
+from auc.policy import ToolPrivilegeGate
+from auc.policy.autonomy import AutonomyPolicy
+from auc.sandbox import SandboxViolationError, resolve_under_sandbox
+from auc.tools import DefaultToolRegistry, make_echo_tool, register_function_tools, tool
+
+__version__ = "0.2.4"
+
+__all__ = [
+    "__version__",
+    "AgentConfig",
+    "AssistantMessage",
+    "AutoApprovePort",
+    "AutonomyPolicy",
+    "CheckpointStore",
+    "ChatMessage",
+    "CodeSnippet",
+    "ContextPackage",
+    "DefaultAgent",
+    "DefaultComposer",
+    "DefaultToolRegistry",
+    "DenyApprovalPort",
+    "EventBus",
+    "FileRulesPort",
+    "InMemoryMemoryPort",
+    "InMemoryModelClient",
+    "ListContextWindow",
+    "LoopConfig",
+    "NoOpMemoryPort",
+    "ReActLoop",
+    "RunEvent",
+    "RunRequest",
+    "RunResult",
+    "SandboxViolationError",
+    "SlicerPolicy",
+    "ToolCall",
+    "ToolPrivilegeGate",
+    "ToolResult",
+    "make_echo_tool",
+    "register_function_tools",
+    "resolve_under_sandbox",
+    "tool",
+]
+
+try:
+    from auc.model.anthropic import AnthropicClient
+    from auc.model.factory import create_model_client, aclose_model_client
+    from auc.model.openai import OpenAICompatibleClient
+
+    __all__.extend(
+        [
+            "AnthropicClient",
+            "OpenAICompatibleClient",
+            "create_model_client",
+            "aclose_model_client",
+            "ModelConfig",
+            "load_model_config",
+            "discover_config_path",
+            "user_config_dir",
+            "default_config_path",
+        ]
+    )
+except ImportError:  # pragma: no cover
+    __all__.extend(
+        [
+            "ModelConfig",
+            "load_model_config",
+            "discover_config_path",
+            "user_config_dir",
+            "default_config_path",
+        ]
+    )
+
+try:
+    from auc.integration import (
+        AuMStack,
+        MetaDispatcher,
+        NuggetsStore,
+        SemanticSlicer,
+        SpecialistRegistry,
+        SpecialistSpec,
+        ConsoleApprovalPort,
+        TelegramApprovalPort,
+    )
+
+    __all__.extend(
+        [
+            "AuMStack",
+            "MetaDispatcher",
+            "NuggetsStore",
+            "SemanticSlicer",
+            "SpecialistRegistry",
+            "SpecialistSpec",
+            "ConsoleApprovalPort",
+            "TelegramApprovalPort",
+        ]
+    )
+except ImportError:  # pragma: no cover
+    pass

auc/agent.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import asyncio
+import uuid
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from auc.checkpoint import CheckpointStore
+from auc.context.compactor import CompactionConfig, SummarizingCompactor
+from auc.context.window import ListContextWindow
+from auc.events.bus import EventBus, RunEvent
+from auc.loop.base import AgentLoopRunner, LoopConfig, LoopContext
+from auc.loop.react import ReActLoop
+from auc.messages import ChatMessage, RunRequest, RunResult
+from auc.model.client import ModelClient
+from auc.plan import READONLY_TOOL_NAMES, render_plan_context
+from auc.policy.autonomy import AutonomyPolicy, normalize_autonomy
+from auc.ports.approval import ApprovalPort
+from auc.ports.memory import ContextComposer, MemoryPort
+from auc.ports.package import ContextPackage, SlicerPolicy
+from auc.ports.rules import ProjectRules, ProjectRulesPort
+from auc.policy.privilege import ToolPrivilegeGate
+from auc.tools.registry import DefaultToolRegistry
+from auc.types import AgentId, AutonomyLevel, RunId
+
+
+@dataclass
+class AgentConfig:
+    agent_id: AgentId
+    model: ModelClient
+    tools: DefaultToolRegistry
+    loop: ReActLoop | None = None
+    memory: MemoryPort | None = None
+    composer: ContextComposer | None = None
+    rules: ProjectRulesPort | None = None
+    approval: ApprovalPort | None = None
+    privilege_gate: ToolPrivilegeGate | None = None
+    slicer_policy: SlicerPolicy | None = None
+    loop_config: LoopConfig = field(default_factory=LoopConfig)
+    system_prompt: str | None = None
+    sandbox_root: str | None = None
+    autonomy: AutonomyLevel = "auto-edit"  # R6 默认级别，可被 metadata.autonomy 覆盖
+    enable_checkpoints: bool = True  # R4
+    compaction: CompactionConfig | None = None  # R3，None 时按 loop_config 构造
+
+
+class DefaultAgent:
+    def __init__(self, config: AgentConfig) -> None:
+        self._config = config
+        self._loop = config.loop or ReActLoop()
+        self._runner = AgentLoopRunner()
+        self._cancelled_runs: set[RunId] = set()
+        self._active_events: dict[RunId, EventBus] = {}
+        self._active_ctx: dict[RunId, LoopContext] = {}
+        self._last_run_result: RunResult | None = None
+
+    @property
+    def agent_id(self) -> AgentId:
+        return self._config.agent_id
+
+    def cancel(self, run_id: RunId) -> None:
+        self._cancelled_runs.add(run_id)
+        ctx = self._active_ctx.get(run_id)
+        if ctx is not None:
+            ctx.cancelled = True
+
+    async def run(self, request: RunRequest | str | list[ChatMessage]) -> RunResult:
+        ctx, bus = await self._prepare_context(self._normalize_request(request))
+        self._active_events[ctx.run_id] = bus
+        self._active_ctx[ctx.run_id] = ctx
+        try:
+            return await self._runner.run_until_done(self._loop, ctx)
+        finally:
+            self._active_events.pop(ctx.run_id, None)
+            self._active_ctx.pop(ctx.run_id, None)
+            self._cancelled_runs.discard(ctx.run_id)
+
+    async def run_stream(
+        self, request: RunRequest | str | list[ChatMessage]
+    ) -> AsyncIterator[RunEvent]:
+        ctx, bus = await self._prepare_context(self._normalize_request(request))
+        queue = bus.create_stream_queue()
+        self._active_events[ctx.run_id] = bus
+        self._active_ctx[ctx.run_id] = ctx
+
+        async def _run() -> RunResult:
+            return await self._runner.run_until_done(self._loop, ctx)
+
+        task = asyncio.create_task(_run())
+        try:
+            while True:
+                event = await queue.get()
+                if event is None:
+                    break
+                yield event
+                if event.type == "run_end":
+                    break
+        finally:
+            bus.close_stream_queue(queue)
+            if not task.done():
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+            try:
+                self._last_run_result = await task
+            except (asyncio.CancelledError, Exception):  # noqa: BLE001
+                self._last_run_result = RunResult(
+                    output="",
+                    messages=ctx.window.view(),
+                    status="error",
+                    run_id=ctx.run_id,
+                    error=str(ctx.error or "cancelled"),
+                )
+            self._active_events.pop(ctx.run_id, None)
+            self._active_ctx.pop(ctx.run_id, None)
+            self._cancelled_runs.discard(ctx.run_id)
+
+    @property
+    def last_run_result(self) -> RunResult | None:
+        return self._last_run_result
+
+    @staticmethod
+    def _normalize_request(
+        request: RunRequest | str | list[ChatMessage],
+    ) -> RunRequest:
+        if isinstance(request, RunRequest):
+            return request
+        return RunRequest(input=request)
+
+    async def _prepare_context(
+        self, request: RunRequest
+    ) -> tuple[LoopContext, EventBus]:
+        run_id = request.run_id or str(uuid.uuid4())
+        if self._config.slicer_policy and self._config.slicer_policy.require_package:
+            if request.context_package is None:
+                raise ValueError(
+                    "context_package required by SlicerPolicy.require_package"
+                )
+
+        window = ListContextWindow()
+        approved_plan = request.metadata.get("approved_plan")
+        if isinstance(approved_plan, dict):
+            window.append(
+                ChatMessage(role="system", content=render_plan_context(approved_plan))
+            )
+        if isinstance(request.input, str):
+            window.append(ChatMessage(role="user", content=request.input))
+        else:
+            for msg in request.input:
+                window.append(msg)
+
+        tools = self._config.tools
+        project_rules: ProjectRules | None = None
+        repo_root = request.metadata.get("repo_root")
+        if self._config.rules and repo_root:
+            project_rules = await self._config.rules.load_rules(str(repo_root))
+            if project_rules.tool_policy:
+                tools = DefaultToolRegistry()
+                for t in self._config.tools._tools.values():
+                    tools.register(t, self._config.tools._policies.get(t.name))
+                tools.merge_tool_policy(project_rules.tool_policy)
+
+        sandbox = self._config.sandbox_root or (
+            str(Path(repo_root).resolve()) if repo_root else None
+        )
+        if sandbox:
+            if project_rules is None:
+                project_rules = ProjectRules(sandbox_root=sandbox)
+            elif not project_rules.sandbox_root:
+                project_rules.sandbox_root = sandbox
+
+        package: ContextPackage | None = request.context_package
+        if package is None and request.metadata.get("context_package"):
+            package = request.metadata["context_package"]
+
+        bus = EventBus()
+        gate = self._config.privilege_gate or ToolPrivilegeGate(
+            approval=self._config.approval
+        )
+
+        # R5：计划模式收窄为只读工具集（按白名单过滤，动态注册工具同样受限）
+        if (
+            request.metadata.get("work_mode") == "plan"
+            or request.metadata.get("readonly_tools") is True
+        ):
+            tools = tools.filtered_view(READONLY_TOOL_NAMES)
+
+        # R6：会话级自治级别（metadata 覆盖配置默认值）
+        autonomy = AutonomyPolicy(
+            level=normalize_autonomy(
+                str(request.metadata.get("autonomy") or self._config.autonomy)
+            )
+        )
+
+        # R4：写前检查点（沙盒内 .auc/checkpoints/，框架特权 IO）
+        checkpoints: CheckpointStore | None = None
+        if sandbox and self._config.enable_checkpoints:
+            checkpoints = CheckpointStore(sandbox)
+
+        # R3：上下文自动压缩
+        compactor: SummarizingCompactor | None = None
+        token_limit = self._config.loop_config.context_token_limit
+        if self._config.compaction is not None:
+            compactor = SummarizingCompactor(
+                self._config.model, self._config.compaction
+            )
+        elif token_limit and token_limit > 0:
+            compactor = SummarizingCompactor(
+                self._config.model, CompactionConfig(token_limit=token_limit)
+            )
+
+        ctx = LoopContext(
+            agent_id=self._config.agent_id,
+            run_id=run_id,
+            window=window,
+            tools=tools,
+            model=self._config.model,
+            events=bus,
+            config=self._config.loop_config,
+            memory=self._config.memory,
+            composer=self._config.composer,
+            context_package=package,
+            project_rules=project_rules,
+            privilege_gate=gate,
+            approval=self._config.approval,
+            system_prompt=self._config.system_prompt,
+            cancelled=run_id in self._cancelled_runs,
+            autonomy_policy=autonomy,
+            checkpoints=checkpoints,
+            compactor=compactor,
+            parent_run_id=request.metadata.get("parent_run_id"),
+        )
+        return ctx, bus

auc/chat_agent.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from typing import TYPE_CHECKING
+
+from auc import AgentConfig, DefaultAgent, DefaultToolRegistry
+from auc.config import ModelConfig, load_merged_settings
+from auc.integration.evolution import EvolutionMemoryPort, make_evolution_tools
+from auc.loop.base import LoopConfig
+from auc.model.factory import create_model_client
+from auc.policy.autonomy import normalize_autonomy
+from auc.policy.escalation import merge_escalation_settings
+from auc.policy.privilege import ToolPrivilegeGate
+from auc.ports import FileRulesPort, SlicerPolicy
+from auc.ports.memory import DefaultComposer
+from auc.tools.fetch import make_fetch_tool
+from auc.tools.files import make_file_tools
+from auc.tools.search import make_search_tools
+from auc.tools.shell import make_shell_tool
+
+if TYPE_CHECKING:
+    from auc.ports.approval import ApprovalPort
+from auc.work_mode import WORK_MODE_OVERVIEW, build_full_system_prompt
+
+DEFAULT_CHAT_BASE = """\
+你是编程助手。工作区根目录（沙盒）为：{sandbox}
+在沙盒内你拥有完整文件系统权限（不可访问沙盒外路径）。
+
+可用工具：
+- read_file(path): 读取 UTF-8 文本
+- write_file(path, content): 写入或创建文件
+- list_dir(path): 列出目录（path 默认 .）
+- delete_path(path): 删除文件或整个目录
+- run_command(command, cwd?, timeout?): 沙盒内执行 shell 命令（跑测试/构建/git 等）；危险命令需用户授权
+- grep_search(pattern, glob?): 按正则搜索文件内容，返回 path:line: text
+- glob_files(pattern): 按名称模式找文件（按修改时间排序）
+- save_lesson(tags, lesson): 固化可复用经验到进化库（跨会话）
+- promote_nugget(nugget_id, tags, content): 将成功经验提升为金块技能
+
+定位代码请优先 grep_search / glob_files，不要逐层 list_dir 遍历。
+改完代码后用 run_command 跑测试验证（如 pytest），失败则修复后复跑。
+
+进化能力（默认开启）：
+- 每轮成功对话会自动写入 .auc/evolution.yaml
+- 启动时会召回 .auc/au-nuggets.yaml 与历史经验
+
+用户要求删除目录/文件时，必须使用 delete_path。
+当用户需要代码或文件时，必须用 write_file 写入工作区。
+
+外部链接：需要网页/文章正文时，使用 fetch_url(url, save_path?)。
+该工具为 L3 高危操作，**必须经用户授权后才会发起网络请求**；未授权时不得声称已访问链接。
+可将结果保存到沙盒文件（save_path）再用 read_file 分析。
+write_file 参数必须是合法 JSON，且同时包含 path 与 content。
+路径使用相对于沙盒的相对路径。
+
+多模态：用户可通过 @图片路径 附加 png/jpg/gif/webp，请结合图片内容回答。
+
+Web 编辑器：用户消息可能附带「当前文件」或「选中代码」。修改需求时：
+1. 优先用 write_file 直接写入工作区，不要只贴代码不保存
+2. 小范围改动保持原文件风格；大范围可拆分多文件
+3. 改完后简要说明改了哪些文件
+
+图表：说明架构、流程、状态时，用 Mermaid（```mermaid ... ```），Web 端会自动渲染。
+支持 flowchart、sequenceDiagram、classDiagram、stateDiagram、erDiagram、gantt、pie、journey、gitGraph、mindmap、timeline、quadrantChart、C4、kanban、sankey、xychart 等全部类型。
+Mermaid 语法要求：
+- subgraph 标题含中文或标点时必须加双引号：subgraph "第一阶段：基础"
+- 节点标签含 emoji、中文、/、空格时用双引号：A["求职 / 研究"]
+- gantt 的 title/section/任务名含冒号、+、/、→ 或中文时用双引号："任务名" :id, after x, 3w
+- 渲染失败时系统会自动尝试修复；若仍失败请输出修正后的完整 ```mermaid``` 块
+"""
+
+# 兼容测试与外部引用：含 {sandbox} 占位符的完整模板
+DEFAULT_CHAT_SYSTEM = (
+    DEFAULT_CHAT_BASE + "\n\n" + WORK_MODE_OVERVIEW
+)
+
+
+def build_chat_system_prompt(
+    sandbox: str,
+    *,
+    extra: str | None = None,
+    include_work_mode: bool = True,
+) -> str:
+    return build_full_system_prompt(
+        sandbox,
+        base=DEFAULT_CHAT_BASE,
+        include_work_mode=include_work_mode,
+        extra=extra,
+    )
+
+
+@dataclass
+class ChatAgentOptions:
+    sandbox: str
+    repo: str | None = None
+    system_prompt: str | None = None
+    evolve: bool = True
+    no_tools: bool = False
+    max_steps: int = 40
+    include_work_mode: bool = True
+
+
+def resolve_sandbox_root(*, sandbox: str | None = None, repo: str | None = None) -> str:
+    if sandbox:
+        return str(Path(sandbox).expanduser().resolve())
+    if repo:
+        return str(Path(repo).expanduser().resolve())
+    return str(Path.cwd().resolve())
+
+
+def build_chat_agent(
+    cfg: ModelConfig,
+    opts: ChatAgentOptions,
+    *,
+    approval: ApprovalPort | None = None,
+) -> DefaultAgent:
+    sandbox = resolve_sandbox_root(sandbox=opts.sandbox, repo=opts.repo)
+    try:
+        settings, _ = load_merged_settings(
+            None, Path(opts.repo) if opts.repo else None
+        )
+    except Exception:  # noqa: BLE001
+        settings = {}
+    memory = (
+        EvolutionMemoryPort(sandbox_root=sandbox) if opts.evolve and not opts.no_tools else None
+    )
+    shell_settings = settings.get("shell") or {}
+    registry = DefaultToolRegistry()
+    if not opts.no_tools:
+        for tool, pol in make_file_tools(sandbox):
+            registry.register(tool, pol)
+        shell_tool, shell_pol = make_shell_tool(
+            sandbox,
+            default_timeout=float(shell_settings.get("default_timeout") or 120),
+            max_timeout=float(shell_settings.get("max_timeout") or 600),
+        )
+        registry.register(shell_tool, shell_pol)
+        for tool, pol in make_search_tools(sandbox):
+            registry.register(tool, pol)
+        if memory is not None:
+            for tool, pol in make_evolution_tools(memory):
+                registry.register(tool, pol)
+        for tool, pol in make_fetch_tool(sandbox):
+            registry.register(tool, pol)
+
+    gate = ToolPrivilegeGate(
+        approval=approval,
+        escalation_rules=merge_escalation_settings(settings.get("escalations")),
+    )
+    system = opts.system_prompt or build_chat_system_prompt(
+        sandbox, include_work_mode=opts.include_work_mode
+    )
+    model = create_model_client(cfg)
+    compaction = settings.get("compaction") or {}
+    loop_config = LoopConfig(
+        max_steps=opts.max_steps,
+        context_token_limit=int(compaction.get("token_limit") or 96_000),
+    )
+    return DefaultAgent(
+        AgentConfig(
+            agent_id="chat",
+            model=model,
+            tools=registry,
+            memory=memory,
+            composer=DefaultComposer(),
+            rules=FileRulesPort() if opts.repo else None,
+            slicer_policy=SlicerPolicy(require_package=False),
+            system_prompt=system,
+            sandbox_root=sandbox,
+            approval=approval,
+            privilege_gate=gate,
+            loop_config=loop_config,
+            autonomy=normalize_autonomy(str(settings.get("autonomy") or "")),
+        )
+    )