请参考 UserRepository.kt 的写法，为 ProductRepository 实现相同的缓存逻辑

// 现有的 BaseViewModel 实现
abstract class BaseViewModel : ViewModel() {
    protected val _loading = MutableStateFlow(false)
}
// 请按此模式实现 UserViewModel

项目使用 MVVM 架构：
- data/ 层：Repository + DataSource
- domain/ 层：UseCase + Model  
- presentation/ 层：ViewModel + Activity/Fragment
使用 Hilt、Room、Retrofit

@MainActivity.kt 这个 Activity 的内存泄漏在哪里？
@app/build.gradle 添加 Coil 图片加载库

git checkout .              # 放弃所有修改
git checkout -- file.kt     # 放弃指定文件修改
git reset HEAD <file>       # 回退暂存区
git reset --hard HEAD^      # 完全回退到上一次提交

#!/usr/bin/env node
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { exec } = require('child_process');
const { promisify } = require('util');
const execPromise = promisify(exec);

const server = new Server({ name: 'adb-server', version: '1.0.0' });

server.tool('adb-logcat', 'Get device logs', async ({ lines = 100 }) => {
  const { stdout } = await execPromise(`adb logcat -d -t ${lines}`);
  return { content: stdout };
});

server.tool('adb-meminfo', 'Get memory usage', async ({ packageName }) => {
  const { stdout } = await execPromise(`adb shell dumpsys meminfo ${packageName}`);
  return { content: stdout };
});

server.tool('adb-install', 'Install APK', async ({ apkPath }) => {
  const { stdout } = await execPromise(`adb install -r ${apkPath}`);
  return { content: stdout };
});

server.start();

{
  "mcpServers": {
    "adb": {
      "command": "node",
      "args": ["/path/to/adb-mcp-server.js"]
    }
  }
}

用户：应用启动时崩溃
AI：[调用 adb-logcat] 发现 NullPointerException in MainActivity:45
     user 对象为 null，建议使用 safe call (?.)

用户：列表滑动很卡
AI：[调用 adb-meminfo] 内存 450MB，ImageLoader 持有 Activity 引用
     建议使用 WeakReference 和 Glide 生命周期管理

Claude Desktop/API → MCP Server → ADB Commands → Android Device

mkdir adb_mcp
cd adb_mcp
npm init -y
npm install @modelcontextprotocol/sdk

{
  "name": "adb-mcp-server",
  "version": "1.0.0",
  "description": "MCP Server for Android Debug Bridge (ADB) operations",
  "main": "adb-mcp-server.js",
  "bin": {
    "adb-mcp-server": "./adb-mcp-server.js"
  },
  "scripts": {
    "start": "node adb-mcp-server.js"
  },
  "keywords": ["mcp", "adb", "android", "debug"],
  "author": "",
  "license": "MIT",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0"
  }
}

#!/usr/bin/env node
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
const { exec } = require('child_process');
const { promisify } = require('util');

const execPromise = promisify(exec);

// 创建 MCP Server 实例
const server = new Server(
  {
    name: 'adb-server',
    version: '1.0.0'
  },
  {
    capabilities: {
      tools: {}
    }
  }
);

// 定义工具列表
const tools = [
  {
    name: 'adb-logcat',
    description: 'Get Android device logs',
    inputSchema: {
      type: 'object',
      properties: {
        lines: {
          type: 'number',
          description: 'Number of log lines to retrieve',
          default: 100
        }
      }
    }
  },
  {
    name: 'adb-devices',
    description: 'List connected Android devices',
    inputSchema: {
      type: 'object',
      properties: {}
    }
  },
  {
    name: 'adb-install',
    description: 'Install APK on connected device',
    inputSchema: {
      type: 'object',
      properties: {
        apkPath: {
          type: 'string',
          description: 'Path to the APK file to install'
        }
      },
      required: ['apkPath']
    }
  },
  {
    name: 'adb-app-info',
    description: 'Get app package information',
    inputSchema: {
      type: 'object',
      properties: {
        packageName: {
          type: 'string',
          description: 'Android package name (e.g., com.example.app)'
        }
      },
      required: ['packageName']
    }
  },
  {
    name: 'adb-meminfo',
    description: 'Get app memory usage information',
    inputSchema: {
      type: 'object',
      properties: {
        packageName: {
          type: 'string',
          description: 'Android package name (e.g., com.example.app)'
        }
      },
      required: ['packageName']
    }
  },
  {
    name: 'adb-clear-data',
    description: 'Clear app data and cache',
    inputSchema: {
      type: 'object',
      properties: {
        packageName: {
          type: 'string',
          description: 'Android package name (e.g., com.example.app)'
        }
      },
      required: ['packageName']
    }
  }
];

// 处理工具列表请求
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return { tools };
});

// 处理工具执行请求
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    let result;

    switch (name) {
      case 'adb-logcat': {
        const lines = args.lines || 100;
        const { stdout } = await execPromise(`adb logcat -d -t ${lines}`);
        result = stdout;
        break;
      }

      case 'adb-devices': {
        const { stdout } = await execPromise('adb devices -l');
        result = stdout;
        break;
      }

      case 'adb-install': {
        if (!args.apkPath) {
          throw new Error('apkPath is required');
        }
        const { stdout } = await execPromise(`adb install -r "${args.apkPath}"`);
        result = stdout;
        break;
      }

      case 'adb-app-info': {
        if (!args.packageName) {
          throw new Error('packageName is required');
        }
        const { stdout } = await execPromise(`adb shell dumpsys package ${args.packageName}`);
        result = stdout;
        break;
      }

      case 'adb-meminfo': {
        if (!args.packageName) {
          throw new Error('packageName is required');
        }
        const { stdout } = await execPromise(`adb shell dumpsys meminfo ${args.packageName}`);
        result = stdout;
        break;
      }

      case 'adb-clear-data': {
        if (!args.packageName) {
          throw new Error('packageName is required');
        }
        const { stdout } = await execPromise(`adb shell pm clear ${args.packageName}`);
        result = stdout;
        break;
      }

      default:
        throw new Error(`Unknown tool: ${name}`);
    }

    return {
      content: [
        {
          type: 'text',
          text: result
        }
      ]
    };
  } catch (error) {
    return {
      content: [
        {
          type: 'text',
          text: `Error executing ${name}: ${error.message}`
        }
      ],
      isError: true
    };
  }
});

// 启动服务器
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error('ADB MCP Server running on stdio');
}

main().catch((error) => {
  console.error('Server error:', error);
  process.exit(1);
});

chmod +x adb-mcp-server.js

const server = new Server(
  { name: 'adb-server', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

{
  name: 'adb-install',
  description: 'Install APK on connected device',
  inputSchema: {
    type: 'object',
    properties: {
      apkPath: { type: 'string', description: 'Path to the APK file' }
    },
    required: ['apkPath']
  }
}

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return { tools };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  // 根据 name 执行相应 ADB 命令
});

const { stdout } = await execPromise(`adb devices -l`);

{
  "mcpServers": {
    "adb": {
      "command": "node",
      "args": ["/Users/你的用户名/Documents/self_host/adb_mcp/adb-mcp-server.js"]
    }
  }
}

claude -p mcp add adb node /Users/xxxx/Documents/sxxx/adb_mcp/adb-mcp-server.js

{
  "mcpServers": {
    "adb": {
      "command": "node",
      "args": ["/Users/xxxx/Documents/sxxx/adb_mcp/adb-mcp-server.js"]
    }
  }
}

{
  "adb": {
    "command": "node",
    "args": ["/Users/xxxx/Documents/sxxx/adb_mcp/adb-mcp-server.js"]
  }
}

查看连接的 Android 设备

获取最近 50 行 logcat 日志

查看 com.android.chrome 的内存使用情况

清除 com.example.app 的数据

adb logcat -d > log.txt
# 手动搜索错误信息

获取最近的 logcat 日志，找出所有 ERROR 级别信息

adb shell dumpsys meminfo com.example.app
# 手动分析输出数据

查看 com.example.app 的内存使用，分析是否有内存泄漏

列出所有连接的设备，在每个设备上安装 /path/to/app.apk

{
  name: 'adb-screenshot',
  description: 'Take a screenshot',
  inputSchema: {
    type: 'object',
    properties: {
      savePath: { type: 'string', description: 'Path to save screenshot' }
    },
    required: ['savePath']
  }
}

await execPromise(`adb exec-out screencap -p > ${args.savePath}`);

{
  name: 'adb-top',
  description: 'Get CPU usage',
  inputSchema: { type: 'object', properties: {} }
}

{
  name: 'adb-push',
  description: 'Push file to device',
  inputSchema: {
    type: 'object',
    properties: {
      localPath: { type: 'string' },
      remotePath: { type: 'string' }
    },
    required: ['localPath', 'remotePath']
  }
}

which adb
adb version

adb devices

# 场景：分析涉及 10 个文件的代码库

# Claude Code CLI (200K 上下文)
# ✓ 可同时加载多个相关文件
# ✓ 保持完整的代码关系理解
# ✓ 前后一致的分析结果

# Copilot CLI (8K 上下文)
# ✗ 只能保持 1-2 个文件
# ✗ 频繁遗忘先前分析内容
# ✗ 需要反复重新读取

{
  "model": "claude-sonnet-4-5-20250929",
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}

用户 → Anthropic API → Claude Sonnet 4.5

用户 → GitHub 编排层 → Anthropic API → Claude Sonnet 4.5

# 单文件读取限制 25K tokens
Error: File content (28375 tokens) exceeds maximum allowed tokens (25000)

# 安装 MCP 服务器（如 Serena MCP）
# 替代低效 grep 检索

/clear   # 清理上下文
/compact # 压缩上下文

/usage  # 查看使用情况

grep -n -C 2 "android.permission.INTERNET" --include="*.out.log" -R ~/.gradle/daemon/ .

~/.gradle/daemon/
├── 5.4.1/
│   ├── daemon-77407.out.log
│   └── daemon-77408.out.log
├── 7.0.2/
│   └── daemon-88901.out.log
└── ...

/daemon/5.4.1/daemon-77407.out.log:132336:Merging uses-permission#android.permission.INTERNET 
with lower [net.butterflytv.utils:rtmp-client:3.0.1] AndroidManifest.xml:11:5-67

Execution failed for task ':react-native-inappbrowser:processDebugManifest'.
> A failure occurred while executing com.android.build.gradle.tasks.ProcessLibraryManifest$ProcessLibWorkAction
> Setting the namespace via the package attribute in the source AndroidManifest.xml is no longer supported.
  Recommendation: remove package="com.proyecto26.inappbrowser" from the source AndroidManifest.xml.

Namespace not specified. Please specify a namespace in the module's build.gradle file like so:

android {
    namespace 'com.example.namespace'
}

allprojects {
    repositories {
        google()
        mavenCentral()
        
        // 如果使用 Detox 测试框架，添加此配置
        maven {
            url("$rootDir/../node_modules/detox/Detox-android")
        }
    }
    
    subprojects {
        afterEvaluate { project ->
            if (project.hasProperty('android')) {
                project.android {
                    // 自动设置 namespace
                    if (namespace == null || namespace.isEmpty()) {
                        def defaultNamespace = project.group.toString().replace('.', '_')
                        namespace = defaultNamespace
                    }

                    // 启用 buildConfig
                    buildFeatures {
                        buildConfig = true
                    }
                }

                // 自动修复 namespace 和清理 AndroidManifest.xml
                project.tasks.register("fixManifestsAndNamespace") {
                    doLast {
                        // 1. 从 AndroidManifest.xml 提取 package 并添加到 build.gradle
                        def buildGradleFile = file("${project.projectDir}/build.gradle")
                        if (buildGradleFile.exists()) {
                            def buildGradleContent = buildGradleFile.getText('UTF-8')
                            def manifestFile = file("${project.projectDir}/src/main/AndroidManifest.xml")
                            if (manifestFile.exists()) {
                                def manifestContent = manifestFile.getText('UTF-8')
                                def packageName = manifestContent.find(/package="([^"]+)"/) { match, p -> p }
                                if (packageName && !buildGradleContent.contains("namespace")) {
                                    println "Setting namespace in ${buildGradleFile}"
                                    buildGradleContent = buildGradleContent.replaceFirst(
                                        /android\s*\{/, "android {\n    namespace '${packageName}'"
                                    )
                                    buildGradleFile.write(buildGradleContent, 'UTF-8')
                                }
                            }
                        }

                        // 2. 移除 AndroidManifest.xml 中的 package 属性
                        def manifests = fileTree(dir: project.projectDir, includes: ['**/AndroidManifest.xml'])
                        manifests.each { File manifestFile ->
                            def manifestContent = manifestFile.getText('UTF-8')
                            if (manifestContent.contains('package=')) {
                                println "Removing package attribute from ${manifestFile}"
                                manifestContent = manifestContent.replaceAll(/package="[^"]*"/, '')
                                manifestFile.write(manifestContent, 'UTF-8')
                            }
                        }
                    }
                }

                // 在构建前自动执行修复
                project.tasks.matching { it.name.startsWith("preBuild") }.all {
                    dependsOn project.tasks.named("fixManifestsAndNamespace")
                }
            }
        }
    }
}

cd android
./gradlew clean
./gradlew assembleDebug

npx react-native run-android

Setting namespace in /path/to/project/android/react-native-inappbrowser/build.gradle
Removing package attribute from /path/to/project/android/react-native-inappbrowser/src/main/AndroidManifest.xml

subprojects {
    afterEvaluate { project ->
        if (project.hasProperty('android')) {
            project.android {
                if (namespace == null || namespace.isEmpty()) {
                    namespace project.group.toString().replace('.', '_')
                }
            }
        }
    }
}

终端 flutter run → ADB 连接 → Android Studio 管理的 ADB 服务器

grep -n -C 1 "Fatal error" app.log

grep -n -A 4 "NullPointerException" stacktrace.txt

gctx() {
  local keyword="$1" file="$2" lines="${3:-1}"
  grep -n --color=always -C "$lines" "$keyword" "$file"
}

FAILURE: Build failed with an exception.
* What went wrong:
Execution failed for task ':app:mergeDebugJavaResource'.
> A failure occurred while executing com.android.build.gradle.internal.tasks.MergeJavaResWorkAction
   > 2 files found with path 'META-INF/versions/9/OSGI-INF/MANIFEST.MF' from inputs:

android {
    packagingOptions {
        resources {
            excludes += "META-INF/versions/9/OSGI-INF/MANIFEST.MF"
        }
    }
}

Caused by: java.lang.RuntimeException: Duplicate class org.tensorflow.lite.DataType found in
modules jetified-litert-api-1.0.1-runtime (com.google.ai.edge.litert:litert-api:1.0.1) and
jetified-tensorflow-lite-api-2.12.0-runtime (org.tensorflow:tensorflow-lite-api:2.12.0)

configurations.all {
    resolutionStrategy.dependencySubstitution {
        substitute module("org.tensorflow:tensorflow-lite") with module("com.google.ai.edge.litert:litert:1.0.1")
    }
}

Caused by: java.lang.RuntimeException: Failed to transform
'/Users/xxxxx/.gradle/caches/modules-2/files-2.1/org.bouncycastle/bcprov-jdk18on/1.78/619aafb92dc0b4c6c
c4cf86c487ca48ee2d67a8e/bcprov-jdk18on-1.78.jar' using Jetifier. 
Reason: IllegalArgumentException, message: Unsupported class file major version 65.

android.jetifier.ignorelist=bcprov-jdk18on-1.78.jar,bcutil-jdk18on-1.78.jar

fatal: unable to read tree <SHA>

git fetch origin
git checkout some-branch

sudo apt-get update
sudo apt-get install util-linux

sudo yum install util-linux

sudo pacman -S util-linux

brew install flock

flock <lockfile> <command>

#!/bin/bash
git fetch origin
git checkout some-branch
# ...more commands...

#!/bin/bash
LOCK_FILE="/path/to/your/repo/.git/deploy.lock"

flock -n "$LOCK_FILE" bash <<'EOF'
git fetch origin
git checkout some-branch
# ...more commands...
EOF

flock -n /path/to/your/repo/.git/deploy.lock ./deploy.sh

f(x) = x²
f(3) = 9  # 永远是 9,在任何时空、任何计算环境

# 数学式的完美幂等
∀x ∈ ℝ: sin(π/2) = 1
# 无论计算多少次,在什么时候计算,结果都是 1

# Python 中的纯函数尝试
def add(a, b):
    return a + b

# 看起来很纯粹,但实际上...
print(add(0.1, 0.2))  # 0.30000000000000004,不是精确的 0.3

# 数学: 0.1 + 0.2 = 0.3
# 编程:
result = 0.1 + 0.2
print(result == 0.3)  # False!
print(result)         # 0.30000000000000004

# 数学中的递归是无限的
# 编程中必须考虑栈溢出
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# fibonacci(100000) → RecursionError: maximum recursion depth exceeded

# 纯函数无法真正与外界交互
def read_file(path):
    # 文件内容可能变化 → 非幂等
    # 文件可能不存在 → 异常处理
    # 磁盘可能损坏 → 外部状态依赖
    with open(path, 'r') as f:
        return f.read()

# 同样的调用,可能返回不同内容
content1 = read_file('data.txt')  # 返回 "Hello"
# 此时文件被修改
content2 = read_file('data.txt')  # 返回 "World"

from datetime import datetime

def get_current_hour():
    return datetime.now().hour

# 同样的函数,不同时刻调用,不同结果
print(get_current_hour())  # 14
# 一小时后
print(get_current_hour())  # 15

-- Haskell 通过类型系统隔离副作用
pureFunction :: Int -> Int
pureFunction x = x * 2

impureFunction :: Int -> IO Int
impureFunction x = do
  currentTime <- getCurrentTime
  return (x + timeToInt currentTime)

class Counter:
    def __init__(self):
        self._value = 0
    
    def increment(self):
        self._value += 1
        return self._value

# 使用示例
counter = Counter()
print(counter.increment())  # 1
print(counter.increment())  # 2
print(counter.increment())  # 3
# 完全非幂等!同样的方法调用,不同的结果

public class UserSession {
    private String token;
    private LocalDateTime lastActivity;
    
    public boolean isValid() {
        // 结果依赖于内部状态
        if (token == null || lastActivity == null) {
            return false;
        }
        
        LocalDateTime now = LocalDateTime.now();
        Duration diff = Duration.between(lastActivity, now);
        return diff.toMinutes() < 30;  
        // 同样的对象,不同时刻,不同结果
    }
}

// 全局配置对象(单例模式)
public class AppConfig {
    private static AppConfig instance;
    private boolean debugMode;
    private User currentUser;
    
    private AppConfig() {
        this.debugMode = false;
        this.currentUser = null;
    }
    
    public static AppConfig getInstance() {
        if (instance == null) {
            instance = new AppConfig();
        }
        return instance;
    }
    
    public User getCurrentUser() {
        return currentUser;
    }
    
    public void setCurrentUser(User user) {
        this.currentUser = user;
    }
}

// 任何方法访问这些状态都变成非幂等
public String getGreeting() {
    AppConfig config = AppConfig.getInstance();
    User user = config.getCurrentUser();
    return user != null ? "Hello, " + user.getName() : "Hello, Guest";
    // 结果依赖全局状态 → 非幂等
}

public class BaseComponent {
    protected boolean initialized = false;
    
    public void init() {
        this.initialized = true;
    }
}

public class ChildComponent extends BaseComponent {
    private int childState = 0;
    
    @Override
    public void init() {
        super.init();
        this.childState = 42;
    }
    
    public int getValue() {
        // 结果依赖于 init() 是否被调用
        return this.initialized ? this.childState : 0;
    }
}

// 使用示例
ChildComponent comp = new ChildComponent();
System.out.println(comp.getValue());  // 0
comp.init();
System.out.println(comp.getValue());  // 42

# Singleton: 全局状态的官方认可
class Database:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connection = None
        return cls._instance
    
    # 现在整个应用都依赖这个单一状态

# Observer: 状态变化的级联效应
class Subject:
    def __init__(self):
        self._observers = []
        self._state = None
    
    def attach(self, observer):
        self._observers.append(observer)
    
    def notify(self):
        for observer in self._observers:
            observer.update(self._state)  # 触发连锁反应

# Python 多线程的竞态条件
import threading

class SharedCounter:
    def __init__(self):
        self.value = 0
    
    def increment(self):
        # 非原子操作!
        temp = self.value
        temp += 1
        self.value = temp

counter = SharedCounter()

def worker():
    for _ in range(1000):
        counter.increment()

# 两个线程同时操作
t1 = threading.Thread(target=worker)
t2 = threading.Thread(target=worker)
t1.start()
t2.start()
t1.join()
t2.join()

print(counter.value)  # 预期 2000,实际可能是 1856、1923...
# 完全不可预测!

# 同样的 prompt,不同的结果
prompt = "请写一个二分查找算法"

response1 = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}]
)
# 可能返回递归实现

response2 = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}]
)
# 可能返回迭代实现

# 即使设置 temperature=0,也无法保证完全相同

# 即使是相同的模型、相同的温度
import anthropic

client = anthropic.Anthropic()

def generate_code(prompt):
    return client.messages.create(
        model="claude-sonnet-4.5",
        max_tokens=1024,
        temperature=0,  # 最低随机性
        messages=[{"role": "user", "content": prompt}]
    )

result1 = generate_code("实现快速排序")
result2 = generate_code("实现快速排序")

# result1 和 result2 可能在变量命名、注释风格、
# 优化策略上有差异

# 简单问题: 相对确定
prompt1 = "1+1等于几?"
# → 几乎总是返回 "2"

# 复杂问题: 高度不确定
prompt2 = """
我有一个 Web 应用,用户反馈加载慢。
技术栈是 React + Node.js + MongoDB。
日活 5000,数据库有 100 万条记录。
请给出优化方案。
"""
# AI 需要假设/推断:
# - 慢在哪里?前端还是后端?
# - 什么查询?是否有索引?
# - 服务器配置如何?
# - 网络状况如何?

# 每次可能给出完全不同的优化建议:
# - 增加索引
# - 实现缓存层
# - 代码分割
# - CDN 加速
# - 数据库分片

# 2023 年 1 月
response = ask_llm("Python 最流行的 Web 框架是什么?")
# → "Django 和 Flask 是最流行的..."

# 2024 年 12 月
response = ask_llm("Python 最流行的 Web 框架是什么?")
# → "FastAPI 近年来非常流行..."

# 同样的问题,因为:
# 1. 模型训练数据更新
# 2. 实际技术趋势变化
# 3. 社区共识演变
# "正确答案"本身就在变化

# 版本 1
prompt_v1 = "写一个排序函数"
# → 可能返回冒泡排序(简单教学版)

# 版本 2(仅添加"高效")
prompt_v2 = "写一个高效的排序函数"
# → 可能返回快速排序或归并排序

# 版本 3(仅添加"生产环境")
prompt_v3 = "写一个生产环境用的排序函数"
# → 可能返回 Tim Sort 并附带详细错误处理

# 微小的措辞差异导致完全不同的输出

prompt = """
请实现一个 HTTP 服务器的接口限流中间件。

技术要求:
- 语言: Python 3.10+
- 框架: Flask
- 算法: 令牌桶(Token Bucket)
- 限流规则: 每 IP 每分钟 100 请求

代码规范:
- 遵循 PEP 8
- 类型注解完整
- 包含 docstring
- 添加单元测试

请给出完整实现,包括:
1. 中间件类定义
2. 配置接口
3. 使用示例
4. 单元测试用例
"""

# 通过详细约束提高输出质量
# 但不同执行可能强调不同方面

# 概率本质: 每个 token 都是从概率分布中采样
def llm_generate(prompt):
    # 简化的概念模型
    context = encode(prompt)
    output = []
    
    for _ in range(max_tokens):
        # 预测下一个 token 的概率分布
        probs = model.predict_next_token(context)
        # {
        #   "def": 0.45,
        #   "class": 0.30,
        #   "import": 0.15,
        #   "from": 0.08,
        #   ...
        # }
        
        # 采样!即使 temperature=0,也是取最高概率
        # 但多个 token 概率接近时,微小的数值差异
        # 就可能导致不同选择
        next_token = sample(probs, temperature)
        output.append(next_token)
        context = update(context, next_token)
    
    return decode(output)

# 每次采样都可能走上不同的路径

prompt = "请计算: 2 + 2 = ?"

# 99.9999% 的情况返回 "4"
# 但理论上可能返回:
# - "4(十进制)"
# - "10(二进制)"
# - "在模 2 算术中等于 0"
# - "这取决于你使用的数制..."
# - 开始解释加法的历史

# 因为 LLM 是模式匹配,不是符号运算
# 完全的幂等性是不可能的

# 纯函数时代: 简单但局限
def calculate_tax(amount):
    return amount * 0.1  # 完全确定,但功能单一

# OOP 时代: 强大但复杂
class ShoppingCart:
    def __init__(self):
        self.items = []
        self.user = None
        self.discounts = []
    
    def add_item(self, item):
        self.items.append(item)
        self.recalculate_total()  # 级联更新
    
    def apply_discount(self, code):
        # 依赖外部 API 验证
        # 依赖用户状态
        # 依赖时间(限时优惠)
        # 完全非幂等
        pass

# AI 时代: 智能但不确定
async def optimize_checkout(cart, user_history):
    prompt = f"""
    用户购物车: {cart}
    历史记录: {user_history}
    请推荐最佳的支付方式和优惠组合
    """
    
    # 每次可能给出不同建议
    return await ai.complete(prompt)

# 数学: 封闭世界假设
# "给定完整的信息,推导确定的结论"
theorem = "∀x ∈ ℕ: x + 0 = x"

# 编程: 开放世界假设
# "在不完整的信息下,做出最佳决策"
def handle_user_input(input_string):
    # 输入可能是任何东西
    # 必须处理边界情况
    # 必须应对意外情况
    if not input_string:
        return default_value()
    try:
        return process(input_string)
    except Exception as e:
        log_error(e)
        return fallback_value()

# AI: 概率世界假设
# "基于模式和统计,生成最可能的答案"
def ai_solve(problem_description):
    # 没有"正确答案"
    # 只有"合理答案"
    # 输出是概率分布的采样
    return sample_from_distribution(
        learned_patterns(problem_description)
    )

# 不是追求"肯定返回 X"
# 而是"90% 概率返回 X 类,10% 概率返回 Y 类"

class AICodeGenerator:
    async def generate_function(self, spec):
        # 生成多个候选
        candidates = await asyncio.gather(*[
            self._generate_once(spec) for _ in range(5)
        ])
        
        # 评估质量分布
        scores = [self._evaluate(c) for c in candidates]
        
        # 选择最优,但承认不确定性
        best_idx = scores.index(max(scores))
        return {
            'code': candidates[best_idx],
            'confidence': max(scores),
            'alternatives': candidates[:3]
        }

# 不是全局幂等,而是关键路径幂等
class PaymentService:
    def __init__(self):
        self._processed = {}  # 幂等性缓存
    
    async def process_payment(self, transaction_id, amount):
        # 这个操作必须幂等!
        if transaction_id in self._processed:
            return self._processed[transaction_id]
        
        # 实际处理(可能非幂等)
        result = await self._execute_payment(amount)
        
        # 缓存结果保证幂等性
        self._processed[transaction_id] = result
        return result
    
    async def _execute_payment(self, amount):
        # 这里可以调用 AI 做风控分析(非幂等)
        risk_score = await ai_risk_assessment(amount)
        if risk_score > 0.8:
            # AI 给出的理由可能每次不同,但决策是幂等的
            raise PaymentRejected("High risk detected")
        
        return await bank_api.charge(amount)

# 对于 AI 生成的代码,不追求幂等性
# 而是通过测试保证正确性

class AIAssistedDevelopment:
    async def implement_feature(self, requirements):
        # 生成多个实现
        implementations = []
        for i in range(3):
            code = await ai.generate_code(requirements)
            implementations.append(code)
        
        # 交叉验证
        test_results = []
        for impl in implementations:
            result = await self._run_tests(impl)
            test_results.append({
                'code': impl,
                'passed': result.passed,
                'coverage': result.coverage,
                'performance': result.performance
            })
        
        # 选择最可靠的实现
        best = max(test_results, key=lambda x: (
            x['passed'],
            x['coverage'],
            -x['performance']  # 越小越好
        ))
        
        return best['code']