aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/engineering/coder.py

@@ -0,0 +1,222 @@
+"""
+agents/engineering/coder.py — Coder Agent
+=========================================
+Engineering agent responsible for translating Quant Strategist Rule Trees
+into self-contained, robust, executable Python / TypeScript backtest scripts.
+Never dumps raw unexecuted code into user dialogue; saves directly to disk.
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+import pathlib
+import re
+import shlex
+import subprocess
+from typing import Any, Awaitable, Callable, Dict, Optional
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class CoderAgent(BaseAgent):
+    name = "coder"
+    description = "编码智能体 — 在指定工作区读写文件；执行命令需宿主明确授权"
+
+    def __init__(
+        self,
+        output_dir: Optional[pathlib.Path] = None,
+        llm_provider=None,
+        data_router=None,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_thought: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[str, Dict], None]] = None,
+        on_tool_end: Optional[Callable[[str, Any], None]] = None,
+        lang: str = "zh",
+        command_approval: Optional[Callable[[list[str], pathlib.Path], bool | Awaitable[bool]]] = None,
+        on_user_question: Optional[Callable[[str], str | Awaitable[str]]] = None,
+    ) -> None:
+        super().__init__(
+            llm_provider=llm_provider,
+            data_router=data_router,
+            on_token=on_token,
+            on_thought=on_thought,
+            on_tool_start=on_tool_start,
+            on_tool_end=on_tool_end,
+            lang=lang,
+        )
+        self.output_dir = (output_dir or pathlib.Path.cwd() / "generated").resolve()
+        self.command_approval = command_approval
+        self.on_user_question = on_user_question
+
+    def _workspace_path(self, raw_path: str, *, required: bool = True) -> pathlib.Path:
+        """Resolve a model-supplied path without allowing access outside the workspace."""
+        if required and not raw_path:
+            raise ValueError("A workspace-relative path is required")
+        path = pathlib.Path(raw_path)
+        if path.is_absolute():
+            raise ValueError("Absolute paths are not allowed")
+        resolved = (self.output_dir / path).resolve()
+        if not resolved.is_relative_to(self.output_dir):
+            raise ValueError("Path escapes the workspace")
+        return resolved
+
+    async def _execute_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> str:
+        if self.on_tool_start:
+            self.on_tool_start(tool_name, tool_args)
+
+        try:
+            if tool_name == "run_command":
+                argv = shlex.split(str(tool_args.get("command", "")))
+                if not argv:
+                    raise ValueError("Command is required")
+                cwd = self._workspace_path(str(tool_args.get("cwd", "")), required=False)
+                if not cwd.is_dir():
+                    raise ValueError("Command directory does not exist")
+                if self.command_approval is None:
+                    result = "Error: command approval is unavailable; command was not run"
+                else:
+                    approved = self.command_approval(argv, cwd)
+                    if inspect.isawaitable(approved):
+                        approved = await approved
+                    if not approved:
+                        result = "Error: command was denied; command was not run"
+                    else:
+                        proc = subprocess.run(argv, shell=False, cwd=cwd, capture_output=True, text=True, timeout=120)
+                        result = f"STDOUT:\n{proc.stdout}\nSTDERR:\n{proc.stderr}\nReturnCode: {proc.returncode}"
+
+            elif tool_name in {"write_file", "read_file", "edit_file_chunk"}:
+                path = self._workspace_path(str(tool_args.get("filename", "")))
+                if tool_name == "write_file":
+                    path.parent.mkdir(parents=True, exist_ok=True)
+                    path.write_text(str(tool_args.get("content", "")), encoding="utf-8")
+                    result = f"Successfully wrote full file to {path}"
+                elif tool_name == "read_file":
+                    lines = path.read_text(encoding="utf-8").splitlines()
+                    result = f"File: {path}\n" + "\n".join(f"{i:04d} | {line}" for i, line in enumerate(lines, 1))
+                else:
+                    target = str(tool_args.get("target_content", ""))
+                    if not target:
+                        raise ValueError("target_content is required")
+                    original = path.read_text(encoding="utf-8")
+                    if target not in original:
+                        result = f"Error: target_content not found in {path}"
+                    else:
+                        path.write_text(original.replace(target, str(tool_args.get("replacement_content", ""))), encoding="utf-8")
+                        result = f"Successfully replaced chunk in {path}"
+
+            elif tool_name == "search_code":
+                query = str(tool_args.get("query", ""))
+                if not query:
+                    raise ValueError("Search query is required")
+                matches: list[str] = []
+                for root, dirs, files in os.walk(self.output_dir, followlinks=False):
+                    dirs[:] = [name for name in dirs if not name.startswith(".")]
+                    for filename in files:
+                        if len(matches) >= 50:
+                            break
+                        path = pathlib.Path(root) / filename
+                        try:
+                            if filename.startswith(".") or not path.resolve().is_relative_to(self.output_dir) or path.stat().st_size > 1_000_000:
+                                continue
+                            lines = path.read_text(encoding="utf-8").splitlines()
+                        except (OSError, UnicodeError):
+                            continue
+                        for line_no, line in enumerate(lines, 1):
+                            if query in line:
+                                matches.append(f"{path.relative_to(self.output_dir)}:{line_no}:{line}")
+                                if len(matches) >= 50:
+                                    break
+                    if len(matches) >= 50:
+                        break
+                result = "\n".join(matches) if matches else "No matches found."
+
+            elif tool_name == "list_dir":
+                path = self._workspace_path(str(tool_args.get("path", "")), required=False)
+                if not path.is_dir():
+                    raise ValueError("Directory does not exist")
+                items: list[str] = []
+                for root, dirs, files in os.walk(path, followlinks=False):
+                    depth = len(pathlib.Path(root).relative_to(path).parts)
+                    if depth >= 3:
+                        dirs[:] = []
+                    dirs[:] = [name for name in dirs if not name.startswith(".")]
+                    items.extend(str((pathlib.Path(root) / name).relative_to(path)) for name in dirs + files if not name.startswith("."))
+                    if len(items) >= 200:
+                        break
+                result = "\n".join(items[:200])
+
+            elif tool_name == "take_screenshot":
+                result = "Error: screenshot capability is not configured; no image was captured"
+
+            elif tool_name == "github_api":
+                repo = str(tool_args.get("repo", ""))
+                issue = str(tool_args.get("issue_number", ""))
+                if tool_args.get("action") != "read_issue" or not re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", repo) or not issue.isdecimal():
+                    raise ValueError("Only read_issue with a valid repository and issue number is supported")
+                proc = subprocess.run(["gh", "issue", "view", issue, "--repo", repo], shell=False, capture_output=True, text=True, timeout=30)
+                result = proc.stdout if proc.returncode == 0 else proc.stderr
+
+            elif tool_name == "ask_user":
+                question = str(tool_args.get("question", ""))
+                if self.on_user_question is None:
+                    result = "Error: user interaction is unavailable; no user response was received"
+                else:
+                    answer = self.on_user_question(question)
+                    if inspect.isawaitable(answer):
+                        answer = await answer
+                    result = f"USER REPLIED: {answer}"
+            else:
+                result = await super()._execute_tool(tool_name, tool_args)
+        except (OSError, ValueError, subprocess.TimeoutExpired) as exc:
+            result = f"Tool Error: {exc}"
+
+        if self.on_tool_end:
+            self.on_tool_end(tool_name, result)
+        return result
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        """
+        Advanced Autonomous Software Engineer Loop (Cursor/Claude Code caliber).
+        """
+        rule_tree = data.get("strategy_rules") or data.get("rule_tree")
+        request_text = data.get("request", "Write a Python script.")
+        
+        system_prompt = (
+            "You are a software engineer working within a bounded local workspace. "
+            "Use workspace-relative paths only. Never claim an action succeeded without a tool result.\n"
+            "Tools: list_dir(path), search_code(query), read_file(filename), "
+            "write_file(filename, content), edit_file_chunk(filename, target_content, replacement_content), "
+            "github_api(action='read_issue', repo='owner/repo', issue_number='123').\n"
+            "run_command(command, cwd) executes an argv command only after host approval. "
+            "If approval is unavailable or denied, do not retry to bypass it; report that verification was not run. "
+            "Shell pipelines, redirects and command substitution are unavailable.\n"
+            "Screenshot capture is unavailable; do not claim visual verification.\n"
+            + ("ask_user(question) forwards a real question to the host.\n" if self.on_user_question else "User interaction is unavailable; do not invent a reply.\n")
+            + "Call a tool with one JSON block per turn: "
+            + '{"type":"tool_call","name":"<tool_name>","args":{}}\n'
+            + "Inspect context, make focused edits, request approved verification, and report observed results."
+        )
+
+        user_prompt = f"Workspace: {self.output_dir}\nTarget Symbol: {symbol}\nRules: {rule_tree}\nUser Request: {request_text}\n\nPlease begin autonomous execution."
+        
+        analysis = await self._call_llm(system_prompt, user_prompt, max_tokens=2500, max_tool_loops=15)
+        
+        report = (
+            f"### Aria Coder - Engineering Report\n\n"
+            f"**项目根目录**：`{self.output_dir.absolute()}`\n\n"
+            f"**执行记录与结果**：\n{analysis}\n"
+        )
+        
+        return AgentResult(
+            agent=self.name,
+            symbol=symbol,
+            analysis=report,
+            confidence=0.5,
+            signal="HOLD",
+            key_points=[],
+            data_used={"workspace": str(self.output_dir)},
+        )

aria_code/agents/engineering/tester.py

@@ -0,0 +1,145 @@
+"""
+agents/engineering/tester.py — Tester & Self-Healing Agent
+=========================================================
+Engineering agent responsible for running fast pre-flight compilation checks,
+sandbox dry-runs, traceback diagnosis, and surgical patch self-healing.
+Delivers concise, high-signal results without terminal log flooding.
+"""
+
+from __future__ import annotations
+
+import logging
+import pathlib
+import sys
+from typing import Any, Callable, Dict, List, Optional
+
+from ..base import BaseAgent, AgentResult
+from aria_code.runtime.self_healing import SelfHealingEngine, SelfHealingResult
+
+logger = logging.getLogger(__name__)
+
+
+class TesterAgent(BaseAgent):
+    __test__ = False
+    name = "tester"
+    description = "测试与自愈智能体 — 负责代码静态预检、沙箱试跑与自动诊断修复"
+
+    def __init__(
+        self,
+        llm_provider=None,
+        data_router=None,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_thought: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[str, Dict], None]] = None,
+        on_tool_end: Optional[Callable[[str, Any], None]] = None,
+        lang: str = "zh",
+        max_retries: int = 3,
+    ) -> None:
+        super().__init__(
+            llm_provider=llm_provider,
+            data_router=data_router,
+            on_token=on_token,
+            on_thought=on_thought,
+            on_tool_start=on_tool_start,
+            on_tool_end=on_tool_end,
+            lang=lang,
+        )
+        self.engine = SelfHealingEngine(python_executable=sys.executable, max_retries=max_retries)
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        """
+        Run test and self-healing on the target script.
+        """
+        script_path_str = data.get("script_path") or data.get("file_path") or ""
+        if not script_path_str:
+            # Look in generated folder
+            gen_path = pathlib.Path.cwd() / "generated" / f"strategy_{symbol.replace('.', '_').replace('-', '_').lower()}.py"
+            if gen_path.exists():
+                script_path_str = str(gen_path)
+            else:
+                return AgentResult(
+                    agent=self.name,
+                    symbol=symbol,
+                    analysis=f"❌ 未找到待测试的代码文件: {symbol}",
+                    confidence=0.0,
+                    signal="HOLD",
+                    error="Missing script_path",
+                )
+
+        target_file = pathlib.Path(script_path_str)
+        if not target_file.exists():
+            return AgentResult(
+                agent=self.name,
+                symbol=symbol,
+                analysis=f"❌ 目标文件不存在: {target_file}",
+                confidence=0.0,
+                signal="HOLD",
+                error=f"File not found: {target_file}",
+            )
+
+        # Run Self-Healing Engine
+        heal_result: SelfHealingResult = await self.engine.execute_and_heal(target_file)
+
+        if heal_result.success:
+            m = heal_result.metrics
+            ann_ret = m.get("annual_return_pct", m.get("total_return_pct", 0.0))
+            sharpe = m.get("sharpe_ratio", 0.0)
+            max_dd = m.get("max_drawdown_pct", 0.0)
+            win_rate = m.get("win_rate_pct", 0.0)
+            trades = m.get("total_trades", 0)
+
+            patch_msg = ""
+            if heal_result.patches_applied:
+                patch_msg = f"\n• 🛠️ 自动诊断与自愈修复: 已应用 {len(heal_result.patches_applied)} 处差量补丁 (未整文件重写)"
+
+            summary = (
+                f"### 🧪 回测执行验证成功\n\n"
+                f"| 关键回测指标 | 数值 |\n"
+                f"| :--- | :--- |\n"
+                f"| **年化收益率 (Annual Return)** | `{ann_ret}%` |\n"
+                f"| **夏普比率 (Sharpe Ratio)** | `{sharpe}` |\n"
+                f"| **最大回撤 (Max Drawdown)** | `{max_dd}%` |\n"
+                f"| **策略胜率 (Win Rate)** | `{win_rate}%` ({trades} 笔交易) |\n\n"
+                f"**产物交付路径**:\n"
+                f"- 策略脚本: `{target_file}`\n"
+                + "\n".join(f"- 输出产物: `{p}`" for p in heal_result.artifact_paths if p != str(target_file))
+                + patch_msg
+            )
+
+            signal = "STRONG_BUY" if sharpe > 1.5 and max_dd < 15.0 else ("BUY" if sharpe > 0.8 else "HOLD")
+
+            return AgentResult(
+                agent=self.name,
+                symbol=symbol,
+                analysis=summary,
+                confidence=0.92,
+                signal=signal,
+                key_points=[
+                    f"Annual Return: {ann_ret}%",
+                    f"Sharpe Ratio: {sharpe}",
+                    f"Max Drawdown: {max_dd}%",
+                    f"Win Rate: {win_rate}%",
+                ],
+                data_used={
+                    "metrics": m,
+                    "artifact_paths": heal_result.artifact_paths,
+                    "patches_applied": heal_result.patches_applied,
+                },
+            )
+        else:
+            return AgentResult(
+                agent=self.name,
+                symbol=symbol,
+                analysis=f"❌ 测试自愈失败: {heal_result.error}",
+                confidence=0.0,
+                signal="HOLD",
+                error=heal_result.error,
+                data_used={"patches_applied": heal_result.patches_applied},
+            )
+
+
+class TesterSelfHealingAgent(TesterAgent):
+    """Alias for TesterAgent."""
+    __test__ = False
+    name = "debugger"
+    description = "调试与自愈智能体 — 负责捕捉 Traceback 并精准修补代码"

aria_code/agents/financial/__init__.py

@@ -0,0 +1,21 @@
+from .technical import TechnicalAgent
+from .macro import MacroAgent
+from .fundamental import FundamentalAgent
+from .risk import RiskAgent
+from .synthesis import SynthesisAgent
+from .strategist import StrategistAgent
+from .corporate_finance import CorporateFinanceAgent
+from .cashflow_burn import CashflowBurnRateAgent
+from .stripe_revenue import StripeRevenueAgent
+
+__all__ = [
+    "TechnicalAgent",
+    "MacroAgent",
+    "FundamentalAgent",
+    "RiskAgent",
+    "SynthesisAgent",
+    "StrategistAgent",
+    "CorporateFinanceAgent",
+    "CashflowBurnRateAgent",
+    "StripeRevenueAgent",
+]

aria_code/agents/financial/cashflow_burn.py

@@ -0,0 +1,119 @@
+"""
+agents/financial/cashflow_burn.py — Cash Flow, Burn Rate & Runway Analysis Agent
+==============================================================================
+Monitors enterprise cash flow sustainability:
+1. Gross Burn vs. Net Burn Rate
+2. Cash Runway (Months of survival under zero revenue or current operations)
+3. Accounts Receivable Aging Breakdown & Bad Debt Risk
+4. Working Capital Liquidity Stress Testing
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+from ..base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+
+class CashflowBurnRateAgent(BaseAgent):
+    name = "cashflow_burn"
+    description = "企业现金流与烧钱率智能体 — 负责现金跑道测算、月度烧钱率与应收账龄风险审计"
+
+    def __init__(
+        self,
+        llm_provider=None,
+        data_router=None,
+        on_token: Optional[Callable[[str], None]] = None,
+        on_thought: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[str, Dict], None]] = None,
+        on_tool_end: Optional[Callable[[str, Any], None]] = None,
+        lang: str = "zh",
+    ) -> None:
+        super().__init__(
+            llm_provider=llm_provider,
+            data_router=data_router,
+            on_token=on_token,
+            on_thought=on_thought,
+            on_tool_start=on_tool_start,
+            on_tool_end=on_tool_end,
+            lang=lang,
+        )
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        """
+        Analyze cash flow, burn rate, and runway.
+        """
+        company_name = symbol or data.get("company_name", "Enterprise")
+        cash = float(data.get("cash", data.get("cash_and_equivalents", 5000000.0)))
+        monthly_inflows = float(data.get("monthly_inflows", data.get("revenue_monthly", 800000.0)))
+        monthly_outflows = float(data.get("monthly_outflows", data.get("expenses_monthly", 1000000.0)))
+        ar_aging = data.get("ar_aging", {
+            "within_30_days": 1200000.0,
+            "days_31_60": 500000.0,
+            "days_61_90": 200000.0,
+            "over_90_days": 100000.0,
+        })
+
+        gross_burn = monthly_outflows
+        net_burn = monthly_outflows - monthly_inflows
+
+        if net_burn > 0:
+            runway_months = cash / net_burn
+            status = "CONCERN" if runway_months < 12.0 else ("SEVERE" if runway_months < 6.0 else "GOOD")
+        else:
+            runway_months = 999.0
+            status = "GOOD"
+
+        total_ar = sum(ar_aging.values())
+        overdue_ar = ar_aging.get("days_61_90", 0.0) + ar_aging.get("over_90_days", 0.0)
+        overdue_pct = (overdue_ar / max(1.0, total_ar)) * 100.0
+
+        runway_str = f"{runway_months:.1f} 个月" if runway_months < 100.0 else "正向自由现金流 (无需消耗现金储备)"
+        burn_str = f"¥{net_burn:,.2f}/月" if net_burn > 0 else f"正向结余 ¥{abs(net_burn):,.2f}/月"
+
+        analysis_text = (
+            f"### 💰 企业现金流与跑道 (Runway) 分析报告: {company_name}\n\n"
+            f"• **当前现金储备**: `¥{cash:,.2f}`\n"
+            f"• **月度净消耗 (Net Burn)**: `{burn_str}` (月支出 `¥{gross_burn:,.2f}`)\n"
+            f"• **现金可持续跑道**: `{runway_str}`\n"
+            f"• **应收账款总额**: `¥{total_ar:,.2f}` (逾期 >60天占比: `{overdue_pct:.1f}%`)\n\n"
+            f"**📊 账龄结构 (AR Aging)**:\n"
+            f"- 30天以内 (正常): `¥{ar_aging.get('within_30_days', 0):,.2f}`\n"
+            f"- 31-60天: `¥{ar_aging.get('days_31_60', 0):,.2f}`\n"
+            f"- 61-90天 (预警): `¥{ar_aging.get('days_61_90', 0):,.2f}`\n"
+            f"- >90天 (高坏账风险): `¥{ar_aging.get('over_90_days', 0):,.2f}`\n\n"
+            f"**💡 资金管理对策**:\n"
+        )
+
+        if net_burn > 0 and runway_months < 12.0:
+            analysis_text += f"- ⚠️ 现金跑道短于 12 个月，需严控固定支出或推进催收逾期款项 ¥{overdue_ar:,.2f}。\n"
+        else:
+            analysis_text += "- ✓ 现金储备处于安全水位，可按计划支持业务拓展。\n"
+
+        if overdue_pct > 15.0:
+            analysis_text += f"- ⚠️ 逾期账款占比达 {overdue_pct:.1f}%，需启动法务/催收介入以防死账坏账。"
+
+        return AgentResult(
+            agent=self.name,
+            symbol=company_name,
+            analysis=analysis_text,
+            confidence=0.93,
+            signal=status,
+            key_points=[
+                f"Cash Reserve: ¥{cash:,.2f}",
+                f"Net Burn Rate: {burn_str}",
+                f"Runway: {runway_str}",
+                f"Overdue AR (>60d): ¥{overdue_ar:,.2f} ({overdue_pct:.1f}%)",
+            ],
+            data_used={
+                "cash": cash,
+                "gross_burn": gross_burn,
+                "net_burn": net_burn,
+                "runway_months": runway_months,
+                "ar_aging": ar_aging,
+            },
+            provenance=["cashflow-runway-engine", "ar-aging-risk-matrix"],
+        )