AI 编程助手经济学 2026：Claude Code、Copilot、Codex 定价深度对比与成本优化策略

"""
AI 编程助手 Token 成本计算器
对比不同方案完成相同编程任务的真实成本
"""
from dataclasses import dataclass
from typing import List


@dataclass
class ModelPricing:
    name: str
    input_cost_per_m: float   # 每百万 input tokens 成本（美元）
    output_cost_per_m: float  # 每百万 output tokens 成本（美元）
    tokenizer_multiplier: float = 1.0  # tokenizer 膨胀系数


@dataclass
class AgentSession:
    file_reads: int      # 文件读取次数
    avg_file_tokens: int  # 平均每次读取的 tokens
    code_gen_tokens: int  # 代码生成的 tokens
    test_iterations: int  # 测试迭代次数
    tool_call_tokens: int # 每次工具调用的 tokens
    conversation_tokens: int  # 对话上下文 tokens


def calculate_session_cost(
    session: AgentSession,
    model: ModelPricing,
) -> dict:
    """计算单次 Agent session 的成本"""
    
    # 文件读取（主要消耗 input tokens）
    input_tokens = (
        session.file_reads * session.avg_file_tokens * model.tokenizer_multiplier
        + session.tool_call_tokens * model.tokenizer_multiplier
    )
    
    # 代码生成（主要消耗 output tokens）
    output_tokens = session.code_gen_tokens
    
    # 对话上下文（每轮迭代都增加 context）
    context_tokens = (
        session.conversation_tokens * session.test_iterations * model.tokenizer_multiplier
    )
    input_tokens += context_tokens
    
    # 测试迭代中的额外消耗
    test_tokens = (
        session.test_iterations * session.tool_call_tokens * model.tokenizer_multiplier
    )
    input_tokens += test_tokens
    
    input_cost = (input_tokens / 1_000_000) * model.input_cost_per_m
    output_cost = (output_tokens / 1_000_000) * model.output_cost_per_m
    total_cost = input_cost + output_cost
    
    return {
        "input_tokens": int(input_tokens),
        "output_tokens": int(output_tokens),
        "total_tokens": int(input_tokens + output_tokens),
        "input_cost": round(input_cost, 4),
        "output_cost": round(output_cost, 4),
        "total_cost": round(total_cost, 4),
    }


# 定义各模型定价
models = {
    "Claude Opus 4.7": ModelPricing("Claude Opus 4.7", 5.0, 25.0, 1.35),
    "Claude Sonnet 4.5": ModelPricing("Claude Sonnet 4.5", 3.0, 15.0, 1.0),
    "GPT-4o": ModelPricing("GPT-4o", 2.5, 10.0, 1.0),
    "Claude Haiku 4.5": ModelPricing("Claude Haiku 4.5", 0.8, 4.0, 1.0),
}

# 典型编程任务：重构一个中型模块
session = AgentSession(
    file_reads=15,          # 读取 15 个相关文件
    avg_file_tokens=8000,   # 平均每文件 8K tokens
    code_gen_tokens=50000,  # 生成 50K tokens 代码
    test_iterations=5,      # 5 次测试迭代
    tool_call_tokens=2000,  # 每次工具调用 2K tokens
    conversation_tokens=10000,  # 每轮对话上下文 10K
)

print("=" * 70)
print("AI 编程助手单次任务成本对比（重构中型模块）")
print("=" * 70)

for name, model in models.items():
    result = calculate_session_cost(session, model)
    print(f"\n{name}:")
    print(f"  Input tokens:  {result['input_tokens']:,}")
    print(f"  Output tokens: {result['output_tokens']:,}")
    print(f"  Total tokens:  {result['total_tokens']:,}")
    print(f"  💰 成本: ${result['total_cost']:.4f}")

# 月度成本估算
print("\n" + "=" * 70)
print("月度成本估算（每天 10 次任务）")
print("=" * 70)
for name, model in models.items():
    result = calculate_session_cost(session, model)
    monthly = result["total_cost"] * 10 * 22  # 每月 22 个工作日
    print(f"{name}: ${monthly:.2f}/月")

"""
智能模型路由：根据任务类型自动选择性价比最优的模型
通过路由策略可以节省 40-70% 的成本
"""
from enum import Enum
from dataclasses import dataclass
from typing import Callable


class TaskComplexity(Enum):
    SIMPLE = "simple"       # 简单任务：代码补全、小修改
    MEDIUM = "medium"       # 中等任务：重构、Bug 修复
    COMPLEX = "complex"     # 复杂任务：架构设计、新功能开发
    REVIEW = "review"       # 代码审查
    DEBUG = "debug"         # 调试和测试


@dataclass
class RoutingRule:
    complexity: TaskComplexity
    model: str
    reasoning: str


# 路由策略表
ROUTING_TABLE = {
    TaskComplexity.SIMPLE: RoutingRule(
        TaskComplexity.SIMPLE, "Haiku 4.5", "简单任务用 Haiku，速度快且成本极低"
    ),
    TaskComplexity.MEDIUM: RoutingRule(
        TaskComplexity.MEDIUM, "Sonnet 4.5", "中等任务用 Sonnet，平衡质量与成本"
    ),
    TaskComplexity.COMPLEX: RoutingRule(
        TaskComplexity.COMPLEX, "Opus 4.7", "复杂任务用 Opus，高质量优先"
    ),
    TaskComplexity.REVIEW: RoutingRule(
        TaskComplexity.REVIEW, "Sonnet 4.5", "代码审查用 Sonnet，足够准确"
    ),
    TaskComplexity.DEBUG: RoutingRule(
        TaskComplexity.DEBUG, "GPT-4o", "调试用 GPT-4o，擅长追踪执行路径"
    ),
}


class SmartModelRouter:
    """智能模型路由器"""
    
    def __init__(self):
        self.usage_stats = {}
    
    def select_model(self, task_description: str) -> str:
        """根据任务描述自动选择模型"""
        complexity = self._classify_complexity(task_description)
        rule = ROUTING_TABLE[complexity]
        print(f"📋 任务: {task_description[:50]}...")
        print(f"🎯 复杂度: {complexity.value}")
        print(f"🤖 选择模型: {rule.model}")
        print(f"💡 理由: {rule.reasoning}")
        print("-" * 50)
        return rule.model
    
    def _classify_complexity(self, description: str) -> TaskComplexity:
        """简单的关键词分类（实际可用 LLM 判断）"""
        desc_lower = description.lower()
        
        # 简单任务关键词
        if any(kw in desc_lower for kw in ["补全", "格式化", "重命名", "小修改"]):
            return TaskComplexity.SIMPLE
        
        # 复杂任务关键词
        if any(kw in desc_lower for kw in ["架构", "设计", "新建模块", "重构系统"]):
            return TaskComplexity.COMPLEX
        
        # 代码审查
        if "审查" in desc_lower or "review" in desc_lower:
            return TaskComplexity.REVIEW
        
        # 调试
        if any(kw in desc_lower for kw in ["调试", "debug", "修复 bug", "测试失败"]):
            return TaskComplexity.DEBUG
        
        # 默认中等
        return TaskComplexity.MEDIUM


# 使用示例
router = SmartModelRouter()

tasks = [
    "补全这个函数的 return 语句",
    "重构用户认证模块，分离 JWT 和 OAuth",
    "审查这段数据库查询代码的性能问题",
    "调试测试用例 test_checkout_flow 失败的原因",
    "设计一个新的插件系统架构",
    "格式化这个 Python 文件的代码风格",
]

print("🧠 智能模型路由演示\n")
for task in tasks:
    router.select_model(task)
    
print("\n✅ 路由策略预计节省成本: 40-70%")
print("   （相比全部使用 Opus 4.7）")

"""
本地 AI 编程助手：使用 Ollama + Aider 实现零成本编码
完全离线运行，无需 API 费用
"""
import subprocess
import os


def setup_ollama():
    """设置 Ollama 和开源模型"""
    commands = [
        # 安装 Ollama（macOS/Linux）
        "curl -fsSL https://ollama.com/install.sh | sh",
        # 拉取代码专用模型（Qwen 系列在编码任务上表现优秀）
        "ollama pull qwen2.5-coder:14b",
        # 如果需要更强的模型（需要 24GB+ 显存）
        # "ollama pull qwen2.5-coder:32b",
    ]
    
    for cmd in commands:
        print(f"⚙️ 执行: {cmd}")
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        if result.returncode != 0:
            print(f"❌ 错误: {result.stderr}")
        else:
            print(f"✅ 完成")


def setup_aider():
    """安装和配置 Aider"""
    commands = [
        "pip install aider-chat",
        # 配置 Aider 使用本地 Ollama 模型
        'export OLLAMA_API_BASE="http://localhost:11434"',
        # 初始化 Aider（在 git 仓库中运行）
        'aider --model ollama/qwen2.5-coder:14b --no-auto-commits',
    ]
    
    print("\n📦 安装 Aider...")
    subprocess.run(commands[0], shell=True)
    
    print("\n💡 Aider 使用示例:")
    print("""
# 在 git 仓库中运行
cd /path/to/your/project

# 启动 Aider
aider --model ollama/qwen2.5-coder:14b

# 然后可以直接对话
# > 帮我给这个函数添加错误处理
# > 重构这个模块，提取公共逻辑
# > 为这些函数写单元测试
    """)


def hybrid_strategy():
    """混合策略：智能切换本地和云端模型"""
    strategy = """
混合策略推荐：
    
1. 日常开发 → 本地模型（Ollama + Qwen2.5-Coder）
   - 成本：~$0
   - 适合：代码补全、小修改、简单重构
   
2. 复杂任务 → Claude Sonnet API
   - 成本：~$3/百万 tokens
   - 适合：架构设计、大规模重构
   
3. 关键决策 → Claude Opus API
   - 成本：~$5/百万 tokens
   - 适合：安全审查、性能优化、核心算法
   
4. 完全离线场景 → 本地 + Aider
   - 成本：~$0
   - 适合：涉密项目、网络不稳定环境
   
预计月度成本：$5-15（相比纯商业方案的 $20-100）
    """
    print(strategy)


if __name__ == "__main__":
    print("🏠 本地 AI 编程助手搭建指南\n")
    print("=" * 50)
    print("方案一：完全本地（零成本）")
    print("=" * 50)
    setup_ollama()
    setup_aider()
    
    print("\n" + "=" * 50)
    print("方案二：混合策略（$5-15/月）")
    print("=" * 50)
    hybrid_strategy()