用户输入 → API 调用 → 流式响应流 → 工具执行 → 结果回传 → 重复

mkdir my-swe-agent
cd my-swe-agent
bun init -y
bun add react ink
bun add -d @types/react typescript

#!/usr/bin/env bun
import React, { useState } from "react";
import { render, Text, Box, useInput, useApp } from "ink";

function REPL() {
  const { exit } = useApp();
  const [input, setInput] = useState("");
  const [history, setHistory] = useState<string[]>([]);

  useInput((_input, key) => {
    if (key.return && input.trim()) {
      setHistory((h) => [...h, `> ${input}`, `[Echo] ${input}`]);
      setInput("");
    } else if (key.escape) {
      exit();
    } else if (key.backspace || key.delete) {
      setInput((i) => i.slice(0, -1));
    } else if (_input) {
      setInput((i) => i + _input);
    }
  });

  return (
    <Box flexDirection="column" height="100%">
      <Box flexDirection="column" flexGrow={1}>
        {history.map((line, i) => (
          <Text key={i}>{line}</Text>
        ))}
      </Box>
      <Box>
        <Text>&gt; {input}</Text>
      </Box>
    </Box>
  );
}

render(<REPL />);

python3 ~/Desktop/code/cc-switcher/app.py &
# 验证代理是否运行
curl http://127.0.0.1:5001/proxy/opencode-go/health

bun add @anthropic-ai/sdk

import Anthropic from "@anthropic-ai/sdk";

const PROXY_BASE_URL = "http://127.0.0.1:5001/proxy/opencode-go";
const DEFAULT_MODEL = "claude-opencode-go-flash";

let client: Anthropic | null = null;

export function getClient(): Anthropic {
  if (!client) {
    client = new Anthropic({
      apiKey: process.env.ANTHROPIC_API_KEY || "sk-proxy-managed",
      baseURL: process.env.ANTHROPIC_BASE_URL || PROXY_BASE_URL,
      timeout: 5 * 60 * 1000,
    });
  }
  return client;
}

export async function* queryModel(params: {
  system: string;
  messages: Array<{ role: "user" | "assistant"; content: string }>;
  tools?: any[];
  maxTokens?: number;
}): AsyncGenerator<string> {
  const anthropic = getClient();
  const stream = await anthropic.messages.create({
    model: process.env.SWE_MODEL || DEFAULT_MODEL,
    max_tokens: params.maxTokens ?? 8192,
    system: params.system,
    messages: params.messages,
    tools: params.tools,
    stream: true,
  });

  for await (const event of stream) {
    if (
      event.type === "content_block_delta" &&
      event.delta.type === "text_delta"
    ) {
      yield event.delta.text;
    }
  }
}

function REPL() {
  const [input, setInput] = useState("");
  const [messages, setMessages] = useState<Message[]>([]);
  const [streamingText, setStreamingText] = useState("");
  const [isProcessing, setIsProcessing] = useState(false);

  const handleSubmit = async () => {
    if (!input.trim() || isProcessing) return;

    const userMsg: Message = { role: "user", content: input };
    const updatedMessages = [...messages, userMsg];
    setMessages(updatedMessages);
    setInput("");
    setIsProcessing(true);
    setStreamingText("...");

    try {
      let fullResponse = "";
      const stream = queryModel({
        system: "You are a helpful coding assistant called SWE Agent.",
        messages: updatedMessages.map((m) => ({
          role: m.role,
          content: typeof m.content === "string" ? m.content : "",
        })),
      });

      for await (const chunk of stream) {
        fullResponse += chunk;
        setStreamingText(fullResponse);
      }

      setMessages((prev) => [
        ...prev,
        { role: "assistant", content: fullResponse },
      ]);
      setStreamingText("");
    } catch (err) {
      setStreamingText(`[Error] ${err}`);
    } finally {
      setIsProcessing(false);
    }
  };

  useInput((_input, key) => {
    if (key.return && input.trim() && !isProcessing) {
      handleSubmit();
    } else if (key.escape) {
      exit();
    } else if (key.backspace || key.delete) {
      setInput((i) => i.slice(0, -1));
    } else if (_input) {
      setInput((i) => i + _input);
    }
  });

  return (
    <Box flexDirection="column">
      <Box flexDirection="column">
        {messages.map((msg, i) => (
          <Box key={i} flexDirection="column">
            <Text bold color={msg.role === "user" ? "green" : "cyan"}>
              {msg.role === "user" ? "> " : "AI: "}
            </Text>
            <Text>{msg.content}</Text>
          </Box>
        ))}
        {streamingText && (
          <Box flexDirection="column">
            <Text bold color="cyan">AI: </Text>
            <Text>{streamingText}</Text>
          </Box>
        )}
      </Box>
      <Box marginTop={1}>
        <Text>{"> "}{input}</Text>
        {isProcessing && <Text dimColor> (processing...)</Text>}
      </Box>
    </Box>
  );
}

import { z } from "zod";

export type ToolContext = {
  cwd: string;
};

export type ToolResult<T = unknown> = {
  data: T;
  isError?: boolean;
};

export type ToolDef = {
  name: string;
  inputSchema: z.ZodType;
  outputSchema?: z.ZodType;
  description?: () => Promise<string>;
  prompt?: () => Promise<string>;
  call: (input: unknown, context: ToolContext) => Promise<ToolResult>;
  isReadOnly?: () => boolean;
  isConcurrencySafe?: () => boolean;
  isEnabled?: () => boolean;
  validateInput?: (input: unknown, ctx: ToolContext) => ValidationResult;
};

export type Tool = {
  name: string;
  inputSchema: z.ZodType;
  outputSchema?: z.ZodType;
  description: () => Promise<string>;
  prompt: () => Promise<string>;
  call: (input: unknown, context: ToolContext) => Promise<ToolResult>;
  isReadOnly: () => boolean;
  isConcurrencySafe: () => boolean;
  isEnabled: () => boolean;
  validateInput?: (input: unknown, ctx: ToolContext) => ValidationResult;
};

type ValidationResult =
  | { result: true }
  | { result: false; message: string };

const TOOL_DEFAULTS = {
  description: async () => "",
  prompt: async () => "",
  isReadOnly: () => false,
  isConcurrencySafe: () => false,
  isEnabled: () => true,
};

export function buildTool<D extends ToolDef>(def: D): Tool {
  return {
    ...TOOL_DEFAULTS,
    ...def,
  };
}

export function createToolContext(cwd?: string): ToolContext {
  return { cwd: cwd ?? process.cwd() };
}

import { execa } from "execa";
import { buildTool } from "../Tool.js";

export const BashTool = buildTool({
  name: "Bash",
  inputSchema: z.object({
    command: z.string().describe("The shell command to execute"),
    description: z.string().optional().describe("What this command does"),
    timeout: z.number().optional().describe("Timeout in milliseconds"),
  }),
  outputSchema: z.object({
    stdout: z.string(),
    stderr: z.string(),
    exitCode: z.number(),
  }),
  isConcurrencySafe: () => false,
  isReadOnly: () => false,

  async prompt() {
    return `## Bash
Executes shell commands. Use this to run code, build, test, etc.
Use full paths and proper quoting. Long-running commands should use &.

Parameters:
- command (required): The shell command to execute
- description (optional): What this command does
- timeout (optional): Timeout in ms (default: 120000)`;
  },

  async call({ command, timeout }) {
    const result = await execa("bash", ["-c", command], {
      timeout: timeout ?? 120_000,
      reject: false,
      all: true,
    });
    return {
      data: {
        stdout: result.stdout ?? "",
        stderr: result.stderr ?? "",
        exitCode: result.exitCode ?? 0,
      },
    };
  },
});

import { readFile } from "fs/promises";
import { buildTool } from "../Tool.js";

export const FileReadTool = buildTool({
  name: "Read",
  inputSchema: z.object({
    file_path: z.string().describe("Absolute path to the file"),
    offset: z.number().optional().describe("Line number to start from (0-based)"),
    limit: z.number().optional().describe("Maximum number of lines to read"),
  }),
  isReadOnly: () => true,
  isConcurrencySafe: () => true,

  async call({ file_path, offset, limit }) {
    const content = await readFile(file_path, "utf-8");
    const lines = content.split("\n");
    const start = offset ?? 0;
    const end = limit ? start + limit : lines.length;
    return {
      data: {
        content: lines.slice(start, end).join("\n"),
        totalLines: lines.length,
        startLine: start,
        endLine: end,
      },
    };
  },
});

import { writeFile, mkdir } from "fs/promises";
import { dirname } from "path";
import { buildTool } from "../Tool.js";

export const FileWriteTool = buildTool({
  name: "Write",
  inputSchema: z.object({
    file_path: z.string().describe("Absolute path to the file"),
    content: z.string().describe("The complete new file content"),
  }),
  isReadOnly: () => false,
  isConcurrencySafe: () => false,

  async call({ file_path, content }) {
    await mkdir(dirname(file_path), { recursive: true });
    await writeFile(file_path, content, "utf-8");
    return {
      data: {
        message: `Written ${content.length} bytes to ${file_path}`,
      },
    };
  },
});

import { glob } from "fs/promises";
import { buildTool } from "../Tool.js";

export const GlobTool = buildTool({
  name: "Glob",
  inputSchema: z.object({
    pattern: z.string().describe("Glob pattern to search (e.g., '**/*.ts')"),
    path: z.string().optional().describe("Directory to search in"),
  }),
  isReadOnly: () => true,
  isConcurrencySafe: () => true,

  async call({ pattern, path }) {
    const cwd = path ?? process.cwd();
    const results: string[] = [];
    for await (const file of glob(pattern, { cwd })) {
      results.push(file);
    }
    return { data: { files: results, count: results.length } };
  },
});

import { execa } from "execa";
import { buildTool } from "../Tool.js";

export const GrepTool = buildTool({
  name: "Grep",
  inputSchema: z.object({
    pattern: z.string().describe("Search pattern (regex supported)"),
    path: z.string().optional().describe("Directory to search in"),
    include: z.string().optional().describe("File glob pattern to include"),
    maxResults: z.number().optional().default(50),
  }),
  isReadOnly: () => true,
  isConcurrencySafe: () => true,

  async call({ pattern, path, include, maxResults }) {
    const args = ["--color", "never", "--line-number", "--with-filename"];
    if (include) args.push("--glob", include);
    args.push("--max-count", String(maxResults ?? 50));
    args.push(pattern);
    if (path) args.push(path);

    const { stdout, exitCode } = await execa("rg", args, {
      reject: false,
      timeout: 30000,
    });

    if (exitCode === 2) return { isError: true, data: { message: "rg failed" } };
    const results = stdout ? stdout.split("\n").filter(Boolean) : [];
    return { data: { results, count: results.length, truncated: results.length >= (maxResults ?? 50) } };
  },
});

import { BashTool } from "./BashTool/BashTool.js";
import { FileReadTool } from "./FileReadTool/FileReadTool.js";
import { FileWriteTool } from "./FileWriteTool/FileWriteTool.js";
import { GlobTool } from "./GlobTool/GlobTool.js";
import { GrepTool } from "./GrepTool/GrepTool.js";
import type { Tool } from "./Tool.js";

export function getAllTools(): Tool[] {
  return [BashTool, FileReadTool, FileWriteTool, GlobTool, GrepTool];
}

src/tools/BashTool/
├── BashTool.ts     ← 核心实现（buildTool 调用）
├── UI.tsx          ← 终端渲染组件
└── index.ts        ← 统一导出

import { BashTool } from "./src/tools/BashTool/BashTool.js";
const result = await BashTool.call(
  { command: "echo hello", timeout: 5000 },
  { cwd: process.cwd() }
);
console.log(result);

type StreamEvent =
  | { type: "message_start"; message: { id: string; content: ContentBlock[] } }
  | { type: "content_block_start"; index: number; content_block: ContentBlock }
  | { type: "content_block_delta"; index: number; delta: TextDelta | ToolUseDelta | ThinkingDelta }
  | { type: "content_block_stop"; index: number }
  | { type: "message_delta"; delta: { stop_reason: string }; usage: Usage }
  | { type: "message_stop" };

type ContentBlock =
  | { type: "text"; text: string }
  | { type: "tool_use"; id: string; name: string; input: object }
  | { type: "thinking"; thinking: string };

import Anthropic from "@anthropic-ai/sdk";
import { getClient } from "./services/api/claude.js";

export interface QueryParams {
  system: string;
  messages: any[];
  tools: Tool[];
  model: string;
  maxTokens?: number;
}

export type ToolUseBlock = {
  id: string;
  name: string;
  input: Record<string, unknown>;
};

export type ToolResultBlock = {
  type: "tool_result";
  tool_use_id: string;
  content: string;
  is_error?: boolean;
};

export type ContentBlock =
  | { type: "text"; text: string }
  | { type: "tool_use"; id: string; name: string; input: object }
  | { type: "thinking"; thinking: string };

export async function* queryLoop(
  params: QueryParams
): AsyncGenerator<any> {
  const { system, messages, tools, model } = params;
  const anthropic = getClient();

  // 这是 Agent 循环——while(true) 直到模型不再调用工具
  while (true) {
    const toolUseBlocks: ToolUseBlock[] = [];
    let currentText = "";

    // 阶段 1：API 调用
    const stream = await anthropic.messages.create({
      model,
      max_tokens: params.maxTokens ?? 8192,
      system,
      messages,
      tools: tools.map(formatToolForAPI),
      stream: true,
    });

    // 阶段 2：处理流式事件
    for await (const event of stream) {
      switch (event.type) {
        case "content_block_start":
          if (event.content_block.type === "tool_use") {
            toolUseBlocks.push({
              id: event.content_block.id,
              name: event.content_block.name,
              input: event.content_block.input as Record<string, unknown>,
            });
          }
          break;

        case "content_block_delta":
          if (event.delta.type === "text_delta") {
            currentText += event.delta.text;
            yield { type: "text", text: event.delta.text };
          }
          break;

        case "message_delta":
          yield { type: "stop_reason", reason: event.delta.stop_reason };
          break;
      }
    }

    // 阶段 3：如果没有工具调用 → 完成
    if (toolUseBlocks.length === 0) {
      messages.push({ role: "assistant", content: currentText });
      return;
    }

    // 阶段 4：构建 assistant 消息（包含文本和工具调用）
    const assistantContent: ContentBlock[] = [];
    if (currentText) {
      assistantContent.push({ type: "text", text: currentText });
    }
    for (const tb of toolUseBlocks) {
      assistantContent.push({
        type: "tool_use",
        id: tb.id,
        name: tb.name,
        input: tb.input,
      });
    }
    messages.push({ role: "assistant", content: assistantContent });

    // 阶段 5：执行每个工具
    const toolResults: ToolResultBlock[] = [];
    for (const tb of toolUseBlocks) {
      const tool = findTool(tb.name);
      if (!tool) {
        toolResults.push({
          type: "tool_result",
          tool_use_id: tb.id,
          content: `Unknown tool: ${tb.name}`,
          is_error: true,
        });
        continue;
      }

      const result = await tool.call(tb.input, { cwd: process.cwd() });
      yield { type: "tool_result", toolUseId: tb.id, data: result.data };

      toolResults.push({
        type: "tool_result",
        tool_use_id: tb.id,
        content: typeof result.data === "string"
          ? result.data
          : JSON.stringify(result.data, null, 2),
      });
    }

    // 阶段 6：工具结果回传 → 继续循环
    // 关键：tool_result 以 user 角色消息的格式发回给 API
    messages.push({ role: "user", content: toolResults });
    // 回到 while(true) 开头，发送新一轮 API 请求
  }
}

function formatToolForAPI(tool: Tool) {
  return {
    name: tool.name,
    description: tool.description,
    input_schema: tool.inputSchema,
  };
}

function findTool(name: string): Tool | undefined {
  return getAllTools().find((t) => t.name === name);
}

async function executeToolsConcurrently(
  toolCalls: ToolUseBlock[],
): Promise<ToolResultBlock[]> {
  // 按并发安全分两组
  const safe = toolCalls.filter(
    (tb) => findTool(tb.name)?.isConcurrencySafe() ?? false
  );
  const unsafe = toolCalls.filter(
    (tb) => !(findTool(tb.name)?.isConcurrencySafe() ?? false)
  );

  // 并发安全的工具并行执行
  const safeResults = await Promise.all(
    safe.map((tb) => executeSingleTool(tb))
  );

  // 不安全的串行执行
  const unsafeResults = [];
  for (const tb of unsafe) {
    unsafeResults.push(await executeSingleTool(tb));
  }

  return [...safeResults, ...unsafeResults];
}

function REPL() {
  const [messages, setMessages] = useState<Message[]>([]);
  const [streamingText, setStreamingText] = useState("");
  const [isProcessing, setIsProcessing] = useState(false);

  const handleSubmit = async (input: string) => {
    if (!input.trim() || isProcessing) return;

    setMessages((m) => [...m, { role: "user", content: input }]);
    setIsProcessing(true);
    setStreamingText("");

    // 维护 API 消息列表
    const apiMessages: ApiMessage[] = [];

    try {
      for await (const event of queryLoop({
        system: "You are a helpful coding assistant.",
        messages: apiMessages,
        tools: getAllTools(),
        model: process.env.SWE_MODEL || "deepseek-v4-flash",
      })) {
        if (event.type === "text") {
          setStreamingText((prev) => prev + event.text);
        }
        if (event.type === "tool_result") {
          setStreamingText(
            (prev) => prev + `\n[Tool ${event.toolUseId} completed]\n`
          );
        }
        if (event.type === "stop_reason") {
          // 模型停止原因
        }
      }
    } catch (err) {
      setStreamingText(`Error: ${err}`);
    }

    setIsProcessing(false);
  };

  // ... 渲染
}

type CommandBase = {
  name: string;
  description: string;
  aliases?: string[];
};

// PromptCommand — 生成提示词发送给 LLM
// 例如 /commit 生成 commit message 模板，然后让模型创建 commit
type PromptCommand = CommandBase & {
  type: "prompt";
  getPromptForCommand(args: string): ContentBlockParam;
};

// LocalCommand — 进程内同步执行，返回纯文本
// 例如 /clear 清空对话，/version 显示版本号
type LocalCommand = CommandBase & {
  type: "local";
  call(args: string): Promise<string | undefined>;
};

// LocalJSXCommand — 返回 React 组件
// 例如 /config 渲染交互式设置编辑器
type LocalJSXCommand = CommandBase & {
  type: "local-jsx";
  render(onDone: () => void): React.ReactNode;
};

type Command = PromptCommand | LocalCommand | LocalJSXCommand;

function processUserInput(input: string, commands: Command[]): ProcessResult {
  // 检查是不是 slash 命令
  if (input.startsWith("/")) {
    const [cmdName, ...args] = input.slice(1).split(" ");
    const cmd = findCommand(cmdName, commands);
    if (!cmd) {
      return { type: "error", message: `Unknown command: /${cmdName}` };
    }

    if (cmd.type === "local") {
      const result = await cmd.call(args.join(" "));
      return { type: "local_result", content: result, shouldQuery: false };
    }

    if (cmd.type === "prompt") {
      const prompt = await cmd.getPromptForCommand(args.join(" "));
      return { type: "prompt", content: prompt, shouldQuery: true };
    }

    // LocalJSXCommand → 渲染交互面板
    return { type: "jsx", component: cmd.render(onDone), shouldQuery: false };
  }

  // 不是 slash 命令，当做普通查询发给 LLM
  return { type: "query", content: input, shouldQuery: true };
}

export const clearCommand: Command = {
  type: "local",
  name: "clear",
  description: "Clear the conversation",
  async call() {
    return "CLEAR_CONVERSATION"; // 特殊标记，告诉 REPL 清空状态
  },
};

import type { Command } from "./types.js";

const commands: Command[] = [];

export function registerCommand(cmd: Command): void {
  commands.push(cmd);
}

export function getCommands(): Command[] {
  return [...commands];
}

export function findCommand(name: string): Command | undefined {
  return commands.find(
    (c) => c.name === name || c.aliases?.includes(name)
  );
}

// 注册内置命令
registerCommand(clearCommand);
registerCommand(helpCommand);

export function buildSystemPrompt(context: PromptContext): string {
  return [
    getIntroduction(),
    getBehaviorRules(),
    getTaskGuidelines(),
    getToolDescriptions(context.tools),
    getEnvironmentInfo(),
    getMemoryContent(context.cwd),
  ].join("\n\n");
}

function getIntroduction(): string {
  return `You is an interactive agent that helps users with software engineering tasks.
You operate in a terminal environment and have access to various tools.`;
}

function getBehaviorRules(): string {
  return `## Core Rules
1. Think step by step before taking action
2. Read files before editing them
3. After editing files, read them again to verify changes
4. Handle errors gracefully and suggest fixes
5. Prefer minimal changes - only modify what's necessary
6. Ask the user before destructive operations
7. If unsure, use available tools to gather more information`;
}

function getTaskGuidelines(): string {
  return `## Task Execution
- Break down complex tasks into smaller steps
- After each step, verify the result before proceeding
- Use Git commands for version control operations
- Write clear, documented code following project conventions`;
}

function getToolDescriptions(tools: Tool[]): string {
  return tools
    .filter((t) => t.isEnabled())
    .map((t) => t.prompt())
    .join("\n\n");
}

function getEnvironmentInfo(): string {
  return `## Environment
- OS: ${process.platform}
- Shell: ${process.env.SHELL || "bash"}
- Working Directory: ${process.cwd()}`;
}

function getMemoryContent(cwd: string): string {
  // 读取 CLAUDE.md 文件（项目级记忆）
  const claudeMdPath = join(cwd, "CLAUDE.md");
  try {
    return readFileSync(claudeMdPath, "utf-8");
  } catch {
    return "";
  }
}

type PermissionAction = "allow" | "deny" | "ask";
type PermissionMode = "default" | "acceptEdits" | "bypassPermissions" | "dontAsk" | "plan" | "auto";

interface PermissionRule {
  permission: string;  // 工具名或 "*"（通配）
  pattern: string;     // 通配符模式
  action: PermissionAction;
}

function hasPermissionsToUseTool(tool, input, context): PermissionResult {
  // 步骤 1a: 全局拒绝规则 → 立即拒绝
  // 例如 "Bash(rm *)" → 所有 rm 命令都被拦截

  // 步骤 1b: 全局询问规则 → 需要用户确认
  // 例如 "Edit" → 所有编辑工具都提示用户

  // 步骤 1c: 工具特定权限 → tool.checkPermissions()
  // BashTool 检查命令是否危险

  // 步骤 1d: 模式检查
  // bypassPermissions → 自动允许
  // plan → 暂停所有执行

  // 步骤 1e: 总是允许规则 → 自动通过

  // 步骤 1f: 默认 → 询问用户
}

Bash(git *)           # 允许所有 git 命令
FileEdit(/src/*)      # 允许编辑 src/ 下的文件
FileRead(*)           # 允许读取任何文件

async checkPermissions({ command }) {
  const dangerous = ["rm -rf /", "mkfs", "dd if=", ":(){ :|:& };:"];
  for (const pattern of dangerous) {
    if (command.includes(pattern)) {
      return { allowed: false, reason: `Dangerous command pattern: ${pattern}` };
    }
  }
  return { allowed: true };
}

function PermissionDialog({ toolName, input, onAllow, onDeny }) {
  return (
    <Box borderStyle="round" borderColor="yellow" padding={1}>
      <Text bold color="yellow">⚠ Tool Permission Request</Text>
      <Text>Tool: {toolName}</Text>
      <Text>Input: {JSON.stringify(input)}</Text>
      <Box marginTop={1}>
        <Text>Press </Text><Text bold>y</Text><Text> to allow, </Text>
        <Text bold>n</Text><Text> to deny</Text>
      </Box>
    </Box>
  );
}

type Listener = () => void;

export interface Store<T> {
  getState: () => T;
  setState: (updater: (prev: T) => T) => void;
  subscribe: (listener: Listener) => () => void;
}

export function createStore<T>(initialState: T): Store<T> {
  let state = initialState;
  const listeners = new Set<Listener>();

  return {
    getState: () => state,
    setState: (updater) => {
      const next = updater(state);
      if (Object.is(next, state)) return;  // 没有变化 → 跳过通知
      state = next;
      listeners.forEach((fn) => fn());
    },
    subscribe: (listener) => {
      listeners.add(listener);
      return () => listeners.delete(listener);
    },
  };
}

import React, { createContext, useContext, useSyncExternalStore } from "react";
import { createStore, type Store } from "./store.js";

export interface AppState {
  sessionID: string | null;
  messages: Message[];
  streamingText: string;
  isStreaming: boolean;
  isProcessing: boolean;
  settings: {
    providerID: string;
    modelID: string;
    maxTurns: number;
    permissionMode: string;
    cwd: string;
  };
  pendingPermissionRequest: PermissionRequest | null;
  cost: {
    sessionCost: number;
    totalInputTokens: number;
    totalOutputTokens: number;
  };
}

export function getDefaultAppState(): AppState {
  return {
    sessionID: null,
    messages: [],
    streamingText: "",
    isStreaming: false,
    isProcessing: false,
    settings: {
      providerID: process.env.SWE_DEFAULT_PROVIDER || "anthropic",
      modelID: process.env.SWE_DEFAULT_MODEL || "claude-sonnet-4-20250514",
      maxTurns: 50,
      permissionMode: "default",
      cwd: process.cwd(),
    },
    pendingPermissionRequest: null,
    cost: { sessionCost: 0, totalInputTokens: 0, totalOutputTokens: 0 },
  };
}

const store = createStore(getDefaultAppState());
const StoreContext = createContext(store);

export function AppStateProvider({ children }: { children: React.ReactNode }) {
  return React.createElement(StoreContext.Provider, { value: store }, children);
}

// 选择器 Hook — 只关心状态的某一部分
export function useAppState<T>(selector: (state: AppState) => T): T {
  const s = useContext(StoreContext);
  return useSyncExternalStore(s.subscribe, () => selector(s.getState()));
}

// 更新函数
export function setState(updater: (prev: AppState) => AppState): void {
  store.setState(updater);
}

src/components/
├── App.tsx              ← 顶层 App（Provider 包装）
├── REPL.tsx             ← 主界面布局
├── Messages.tsx         ← 消息列表
├── MessageBubble.tsx    ← 单条消息（用户/助手/系统/工具）
├── PromptInput.tsx      ← 输入框（历史导航、自动补全）
├── Spinner.tsx          ← 加载动画
├── StatusBar.tsx        ← 底栏（状态、模型信息）
├── ToolCallDisplay.tsx  ← 工具调用可视化
├── PermissionDialog.tsx ← 权限对话框
└── ErrorBoundary.tsx    ← 错误边界

const ROLE_COLORS: Record<string, string> = {
  user: "green",
  assistant: "cyan",
  system: "yellow",
  tool: "magenta",
};

const ROLE_LABELS: Record<string, string> = {
  user: "You",
  assistant: "Assistant",
  system: "System",
  tool: "Tool",
};

export function MessageBubble({ role, content, isStreaming }: MessageBubbleProps) {
  return (
    <Box flexDirection="column" marginY={0}>
      <Text color={ROLE_COLORS[role] || "white"}>
        ▌ {ROLE_LABELS[role] || role}
      </Text>
      <Box marginLeft={2}>
        <Text>{content}</Text>
        {isStreaming && <Text dimColor>▊</Text>}
      </Box>
    </Box>
  );
}

export const FileEditTool = buildTool({
  name: "Edit",
  inputSchema: z.object({
    file_path: z.string().describe("Absolute path to the file"),
    old_string: z.string().describe("The exact text to replace (must appear exactly once)"),
    new_string: z.string().describe("The replacement text"),
  }),

  async call({ file_path, old_string, new_string }) {
    const content = await readFile(file_path, "utf-8");
    const count = content.split(old_string).length - 1;

    if (count === 0) {
      return {
        isError: true,
        data: { message: `String not found. Read the file first to see exact content.` },
      };
    }

    if (count > 1) {
      return {
        isError: true,
        data: { message: `Found ${count} occurrences. Include more surrounding context.` },
      };
    }

    const newContent = content.replace(old_string, new_string);
    await writeFile(file_path, newContent, "utf-8");
    return { data: { message: `Applied edit to ${file_path}` } };
  },
});

export const TodoWriteTool = buildTool({
  name: "TodoWrite",
  inputSchema: z.object({
    task: z.string().describe("Task description"),
    status: z.enum(["pending", "in_progress", "completed"]).default("pending"),
  }),
  isReadOnly: () => false,

  async call({ task, status }) {
    // 将任务写入 todo 文件
    const todoFile = join(process.cwd(), ".swe-tasks.json");
    let todos: any[] = [];
    try { todos = JSON.parse(await readFile(todoFile, "utf-8")); } catch {}
    todos.push({ task, status, createdAt: new Date().toISOString() });
    await writeFile(todoFile, JSON.stringify(todos, null, 2));
    return { data: { message: `Task created: ${task}` } };
  },
});

export class CostTracker {
  private totalInputTokens = 0;
  private totalOutputTokens = 0;
  private modelRates: Record<string, { input: number; output: number }> = {
    "claude-sonnet-4-20250514": { input: 3.0, output: 15.0 },
    "claude-haiku-3-5-20241022": { input: 0.25, output: 1.25 },
  };

  addUsage(inputTokens: number, outputTokens: number, model: string): void {
    this.totalInputTokens += inputTokens;
    this.totalOutputTokens += outputTokens;
  }

  getTotalCost(model: string): number {
    const rates = this.modelRates[model] || { input: 0, output: 0 };
    return (this.totalInputTokens / 1000000) * rates.input +
           (this.totalOutputTokens / 1000000) * rates.output;
  }

  getStats(): { inputTokens: number; outputTokens: number; totalCost: number } {
    return {
      inputTokens: this.totalInputTokens,
      outputTokens: this.totalOutputTokens,
      totalCost: this.getTotalCost("claude-sonnet-4-20250514"),
    };
  }
}

async function compactMessages(
  messages: Message[],
  threshold: number = 80000,
): Promise<Message[]> {
  const totalTokens = estimateTokens(messages);
  if (totalTokens <= threshold) return messages;

  // 压缩策略：将早期的对话轮次汇总为摘要
  const summaryModel = "claude-haiku-3-5-20241022"; // 使用更便宜的模型
  const earlyMessages = messages.slice(0, Math.floor(messages.length / 2));
  const summary = await generateSummary(earlyMessages, summaryModel);

  return [
    { role: "system", content: `[Previous conversation summary: ${summary}]` },
    ...messages.slice(Math.floor(messages.length / 2)),
  ];
}

interface MCPConfig {
  name: string;
  command: string;
  args?: string[];
  env?: Record<string, string>;
}

class MCPManager {
  private servers: Map<string, MCPConnection> = new Map();

  async connect(config: MCPConfig): Promise<void> {
    // 启动 MCP 服务器子进程
    // 通过 stdio 传输通信
    // 发现可用工具
    // 注册到工具注册表
  }

  async callTool(serverName: string, toolName: string, args: unknown): Promise<unknown> {
    // 向 MCP 服务器发送工具调用请求
  }
}

export const AgentTool = buildTool({
  name: "AgentTool",
  inputSchema: z.object({
    prompt: z.string().describe("Task for the sub-agent"),
    background: z.boolean().optional().default(false).describe("Run in background"),
  }),

  async call({ prompt, background }) {
    // 创建新的 AgentEngine 实例作为子智能体
    const subAgent = new AgentEngine({
      provider: process.env.SWE_DEFAULT_PROVIDER || "anthropic",
      model: process.env.SWE_DEFAULT_MODEL || "claude-sonnet-4-20250514",
      systemPrompt: "You are a helpful sub-agent.",
      maxTurns: 20,
    });

    if (background) {
      // 后台运行，不阻塞主 Agent
      subAgent.submitMessage([{ role: "user", content: prompt }]);
      return { data: { status: "running_in_background" } };
    }

    // 前台运行
    const result: string[] = [];
    for await (const event of subAgent.submitMessage([
      { role: "user", content: prompt },
    ])) {
      if (event.type === "text-delta") result.push(event.textDelta);
      else if (event.type === "tool-call") {
        result.push(`\n[Tool: ${event.toolName}]\n`);
      }
    }
    return { data: { status: "completed", result: result.join("") } };
  },
});

// 测试 BashTool 的安全检查
describe("BashTool", () => {
  it("blocks dangerous commands", async () => {
    const result = await BashTool.checkPermissions(
      { command: "rm -rf /", description: "", timeout: 5000 },
      { cwd: "/tmp" }
    );
    expect(result.allowed).toBe(false);
  });

  it("allows safe commands", async () => {
    const result = await BashTool.checkPermissions(
      { command: "ls -la", description: "", timeout: 5000 },
      { cwd: "/tmp" }
    );
    expect(result.allowed).toBe(true);
  });
});

// 测试完整的 Agent 循环（mock LLM）
describe("AgentEngine", () => {
  it("executes tool calls in sequence", async () => {
    // mock 一个返回 tool_use 的 LLM
    // 验证工具被执行
    // 验证结果被反馈给模型
  });
});

my-swe-agent/
├── src/
│   ├── main.tsx                  ← CLI 入口
│   ├── repl.tsx                  ← REPL 交互会话
│   ├── query.ts                  ← 核心查询循环
│   ├── QueryEngine.ts            ← 查询引擎封装
│   │
│   ├── services/api/claude.ts    ← Anthropic API 客户端
│   │
│   ├── tools/
│   │   ├── Tool.ts               ← buildTool 工厂 + 类型
│   │   ├── registry.ts           ← 工具注册表
│   │   ├── BashTool/             ← Shell 执行
│   │   ├── FileReadTool/         ← 文件读取
│   │   ├── FileWriteTool/        ← 文件写入
│   │   ├── FileEditTool/         ← 文件编辑
│   │   ├── GlobTool/             ← 文件搜索
│   │   └── GrepTool/             ← 内容搜索
│   │
│   ├── commands/
│   │   ├── registry.ts           ← 命令注册表
│   │   ├── help.ts               ← /help 命令
│   │   └── clear.ts              ← /clear 命令
│   │
│   ├── components/
│   │   ├── App.tsx               ← 顶层应用
│   │   ├── REPL.tsx              ← 主界面
│   │   ├── Messages.tsx          ← 消息列表
│   │   ├── MessageBubble.tsx     ← 消息气泡
│   │   ├── PromptInput.tsx       ← 输入框
│   │   ├── Spinner.tsx           ← 加载指示器
│   │   ├── StatusBar.tsx         ← 状态栏
│   │   └── ErrorBoundary.tsx     ← 错误边界
│   │
│   ├── state/
│   │   ├── store.ts              ← Store 工厂
│   │   └── AppState.ts           ← 应用状态
│   │
│   ├── prompts/system.ts         ← 系统提示词构建
│   │
│   └── utils/
│       ├── config.ts             ← 配置管理
│       └── messages.ts           ← 消息工具
│
├── package.json
├── tsconfig.json
└── README.md