1
2

export ANTHROPIC_API_KEY="your-key"
python nanocode.py

1
2

export OPENROUTER_API_KEY="your-key"
python nanocode.py

1
2
3

export OPENROUTER_API_KEY="your-key"
export MODEL="openai/gpt-5.2"
python nanocode.py

1
2
3
4
5
6
7
8

────────────────────────────────────────
❯ what files are here?
────────────────────────────────────────

⏺ Glob(**/*.py)
  ⎿  nanocode.py

⏺ There's one Python file: nanocode.py

1
2

export ANTHROPIC_API_KEY="你的API密钥"
python nanocode.py

1
2

export OPENROUTER_API_KEY="你的API密钥"
python nanocode.py

1
2
3

export OPENROUTER_API_KEY="你的API密钥"
export MODEL="openai/gpt-5.2"
python nanocode.py

1
2
3

❯ how many files in this folder?
────────────────────────────────────────────────────────────────────────────────
⏺ Error: Expecting value: line 1 column 1 (char 0)

1
2
3
4
5
6
7
8

────────────────────────────────────────
❯ 这里有哪些文件？
────────────────────────────────────────

⏺ 执行文件匹配(**/*.py)
  ⎿  nanocode.py

⏺ 当前目录下存在一个Python文件：nanocode.py

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271

#!/usr/bin/env python3
"""nanocode - minimal claude code alternative"""

import glob as globlib, json, os, re, subprocess, urllib.request

OPENROUTER_KEY = os.environ.get("OPENROUTER_API_KEY")
API_URL = "https://openrouter.ai/api/v1/messages" if OPENROUTER_KEY else "https://api.anthropic.com/v1/messages"
MODEL = os.environ.get("MODEL", "anthropic/claude-opus-4.5" if OPENROUTER_KEY else "claude-opus-4-5")

# ANSI colors
RESET, BOLD, DIM = "\033[0m", "\033[1m", "\033[2m"
BLUE, CYAN, GREEN, YELLOW, RED = (
    "\033[34m",
    "\033[36m",
    "\033[32m",
    "\033[33m",
    "\033[31m",
)


# --- Tool implementations ---


def read(args):
    lines = open(args["path"]).readlines()
    offset = args.get("offset", 0)
    limit = args.get("limit", len(lines))
    selected = lines[offset : offset + limit]
    return "".join(f"{offset + idx + 1:4}| {line}" for idx, line in enumerate(selected))


def write(args):
    with open(args["path"], "w") as f:
        f.write(args["content"])
    return "ok"


def edit(args):
    text = open(args["path"]).read()
    old, new = args["old"], args["new"]
    if old not in text:
        return "error: old_string not found"
    count = text.count(old)
    if not args.get("all") and count > 1:
        return f"error: old_string appears {count} times, must be unique (use all=true)"
    replacement = (
        text.replace(old, new) if args.get("all") else text.replace(old, new, 1)
    )
    with open(args["path"], "w") as f:
        f.write(replacement)
    return "ok"


def glob(args):
    pattern = (args.get("path", ".") + "/" + args["pat"]).replace("//", "/")
    files = globlib.glob(pattern, recursive=True)
    files = sorted(
        files,
        key=lambda f: os.path.getmtime(f) if os.path.isfile(f) else 0,
        reverse=True,
    )
    return "\n".join(files) or "none"


def grep(args):
    pattern = re.compile(args["pat"])
    hits = []
    for filepath in globlib.glob(args.get("path", ".") + "/**", recursive=True):
        try:
            for line_num, line in enumerate(open(filepath), 1):
                if pattern.search(line):
                    hits.append(f"{filepath}:{line_num}:{line.rstrip()}")
        except Exception:
            pass
    return "\n".join(hits[:50]) or "none"


def bash(args):
    proc = subprocess.Popen(
        args["cmd"], shell=True,
        stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
        text=True
    )
    output_lines = []
    try:
        while True:
            line = proc.stdout.readline()
            if not line and proc.poll() is not None:
                break
            if line:
                print(f"  {DIM}│ {line.rstrip()}{RESET}", flush=True)
                output_lines.append(line)
        proc.wait(timeout=30)
    except subprocess.TimeoutExpired:
        proc.kill()
        output_lines.append("\n(timed out after 30s)")
    return "".join(output_lines).strip() or "(empty)"


# --- Tool definitions: (description, schema, function) ---

TOOLS = {
    "read": (
        "Read file with line numbers (file path, not directory)",
        {"path": "string", "offset": "number?", "limit": "number?"},
        read,
    ),
    "write": (
        "Write content to file",
        {"path": "string", "content": "string"},
        write,
    ),
    "edit": (
        "Replace old with new in file (old must be unique unless all=true)",
        {"path": "string", "old": "string", "new": "string", "all": "boolean?"},
        edit,
    ),
    "glob": (
        "Find files by pattern, sorted by mtime",
        {"pat": "string", "path": "string?"},
        glob,
    ),
    "grep": (
        "Search files for regex pattern",
        {"pat": "string", "path": "string?"},
        grep,
    ),
    "bash": (
        "Run shell command",
        {"cmd": "string"},
        bash,
    ),
}


def run_tool(name, args):
    try:
        return TOOLS[name][2](args)
    except Exception as err:
        return f"error: {err}"


def make_schema():
    result = []
    for name, (description, params, _fn) in TOOLS.items():
        properties = {}
        required = []
        for param_name, param_type in params.items():
            is_optional = param_type.endswith("?")
            base_type = param_type.rstrip("?")
            properties[param_name] = {
                "type": "integer" if base_type == "number" else base_type
            }
            if not is_optional:
                required.append(param_name)
        result.append(
            {
                "name": name,
                "description": description,
                "input_schema": {
                    "type": "object",
                    "properties": properties,
                    "required": required,
                },
            }
        )
    return result


def call_api(messages, system_prompt):
    request = urllib.request.Request(
        API_URL,
        data=json.dumps(
            {
                "model": MODEL,
                "max_tokens": 8192,
                "system": system_prompt,
                "messages": messages,
                "tools": make_schema(),
            }
        ).encode(),
        headers={
            "Content-Type": "application/json",
            "anthropic-version": "2023-06-01",
            **({"Authorization": f"Bearer {OPENROUTER_KEY}"} if OPENROUTER_KEY else {"x-api-key": os.environ.get("ANTHROPIC_API_KEY", "")}),
        },
    )
    response = urllib.request.urlopen(request)
    return json.loads(response.read())


def separator():
    return f"{DIM}{'─' * min(os.get_terminal_size().columns, 80)}{RESET}"


def render_markdown(text):
    return re.sub(r"\*\*(.+?)\*\*", f"{BOLD}\\1{RESET}", text)


def main():
    print(f"{BOLD}nanocode{RESET} | {DIM}{MODEL} ({'OpenRouter' if OPENROUTER_KEY else 'Anthropic'}) | {os.getcwd()}{RESET}\n")
    messages = []
    system_prompt = f"Concise coding assistant. cwd: {os.getcwd()}"

    while True:
        try:
            print(separator())
            user_input = input(f"{BOLD}{BLUE}❯{RESET} ").strip()
            print(separator())
            if not user_input:
                continue
            if user_input in ("/q", "exit"):
                break
            if user_input == "/c":
                messages = []
                print(f"{GREEN}⏺ Cleared conversation{RESET}")
                continue

            messages.append({"role": "user", "content": user_input})

            # agentic loop: keep calling API until no more tool calls
            while True:
                response = call_api(messages, system_prompt)
                content_blocks = response.get("content", [])
                tool_results = []

                for block in content_blocks:
                    if block["type"] == "text":
                        print(f"\n{CYAN}⏺{RESET} {render_markdown(block['text'])}")

                    if block["type"] == "tool_use":
                        tool_name = block["name"]
                        tool_args = block["input"]
                        arg_preview = str(list(tool_args.values())[0])[:50]
                        print(
                            f"\n{GREEN}⏺ {tool_name.capitalize()}{RESET}({DIM}{arg_preview}{RESET})"
                        )

                        result = run_tool(tool_name, tool_args)
                        result_lines = result.split("\n")
                        preview = result_lines[0][:60]
                        if len(result_lines) > 1:
                            preview += f" ... +{len(result_lines) - 1} lines"
                        elif len(result_lines[0]) > 60:
                            preview += "..."
                        print(f"  {DIM}⎿  {preview}{RESET}")

                        tool_results.append(
                            {
                                "type": "tool_result",
                                "tool_use_id": block["id"],
                                "content": result,
                            }
                        )

                messages.append({"role": "assistant", "content": content_blocks})

                if not tool_results:
                    break
                messages.append({"role": "user", "content": tool_results})

            print()

        except (KeyboardInterrupt, EOFError):
            break
        except Exception as err:
            print(f"{RED}⏺ Error: {err}{RESET}")


if __name__ == "__main__":
    main()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#!/usr/bin/env python3
"""nanocode - minimal claude code alternative"""

# 导入内置依赖库，无需额外安装
import glob as globlib, json, os, re, subprocess, urllib.request

# 1. 读取环境变量，配置API相关参数
# 读取OpenRouter API密钥（优先使用OpenRouter，无则使用Anthropic）
OPENROUTER_KEY = os.environ.get("OPENROUTER_API_KEY")
# 确定API请求地址：有OpenRouter密钥则用OpenRouter，否则用Anthropic
API_URL = "https://openrouter.ai/api/v1/messages" if OPENROUTER_KEY else "https://api.anthropic.com/v1/messages"
# 确定使用的模型：优先从环境变量读取，无则默认对应平台的高性能模型
MODEL = os.environ.get("MODEL", "anthropic/claude-opus-4.5" if OPENROUTER_KEY else "claude-opus-4-5")

# 2. 定义ANSI终端转义序列，实现彩色输出和格式控制
RESET, BOLD, DIM = "\033[0m", "\033[1m", "\033[2m"  # 重置、加粗、暗淡
BLUE, CYAN, GREEN, YELLOW, RED = (
    "\033[34m",
    "\033[36m",
    "\033[32m",
    "\033[33m",
    "\033[31m",
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def read(args):
    # 打开文件并按行读取所有内容
    lines = open(args["path"]).readlines()
    # 获取偏移量（默认从第0行开始）和读取限制（默认读取全部）
    offset = args.get("offset", 0)
    limit = args.get("limit", len(lines))
    # 截取指定范围的行
    selected = lines[offset : offset + limit]
    # 拼接结果，附带行号（格式：4位数字| 行内容），提升可读性
    return "".join(f"{offset + idx + 1:4}| {line}" for idx, line in enumerate(selected))

1
2
3
4
5

def write(args):
    # 以"w"（写入模式）打开文件，不存在则创建，存在则覆盖
    with open(args["path"], "w") as f:
        f.write(args["content"])
    return "ok"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

def edit(args):
    # 读取文件全部内容
    text = open(args["path"]).read()
    old, new = args["old"], args["new"]
    # 校验1：旧字符串是否存在
    if old not in text:
        return "error: old_string not found"
    count = text.count(old)
    # 校验2：未指定all=true时，旧字符串必须唯一（避免误替换）
    if not args.get("all") and count > 1:
        return f"error: old_string appears {count} times, must be unique (use all=true)"
    # 执行替换：all=true则替换所有，否则只替换第1次出现
    replacement = (
        text.replace(old, new) if args.get("all") else text.replace(old, new, 1)
    )
    # 写入替换后的内容（覆盖原文件）
    with open(args["path"], "w") as f:
        f.write(replacement)
    return "ok"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def glob(args):
    # 拼接文件查找模式（处理路径中的双斜杠，转为单斜杠）
    pattern = (args.get("path", ".") + "/" + args["pat"]).replace("//", "/")
    # 递归查找符合模式的所有文件/目录
    files = globlib.glob(pattern, recursive=True)
    # 排序：按文件修改时间（mtime）倒序，非文件（目录）排最后
    files = sorted(
        files,
        key=lambda f: os.path.getmtime(f) if os.path.isfile(f) else 0,
        reverse=True,
    )
    # 返回结果：换行分隔文件路径，无结果返回"none"
    return "\n".join(files) or "none"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

def grep(args):
    # 编译正则表达式模式，提升匹配效率
    pattern = re.compile(args["pat"])
    hits = []
    # 递归遍历所有文件/目录
    for filepath in globlib.glob(args.get("path", ".") + "/**", recursive=True):
        try:
            # 按行读取文件，检索匹配内容
            for line_num, line in enumerate(open(filepath), 1):
                if pattern.search(line):
                    # 记录：文件路径:行号:匹配行内容（去除末尾换行符）
                    hits.append(f"{filepath}:{line_num}:{line.rstrip()}")
        except Exception:
            pass  # 忽略无法读取的文件（如目录、权限不足文件）
    # 返回前50条匹配结果，避免结果过多溢出
    return "\n".join(hits[:50]) or "none"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def bash(args):
    # 启动子进程执行Shell命令，捕获标准输出/错误输出
    proc = subprocess.Popen(
        args["cmd"], shell=True,
        stdout=subprocess.PIPE, stderr=subprocess.STDOUT,  # 标准错误重定向到标准输出
        text=True  # 以文本模式读取输出，而非字节流
    )
    output_lines = []
    try:
        # 实时读取子进程输出，并打印到终端
        while True:
            line = proc.stdout.readline()
            # 终止条件：无输出且进程已退出
            if not line and proc.poll() is not None:
                break
            if line:
                print(f"  {DIM}│ {line.rstrip()}{RESET}", flush=True)
                output_lines.append(line)
        # 等待进程执行完成，超时30秒
        proc.wait(timeout=30)
    except subprocess.TimeoutExpired:
        # 超时后杀死进程，记录超时信息
        proc.kill()
        output_lines.append("\n(timed out after 30s)")
    # 返回命令执行结果（去除首尾空白，无结果返回"(empty)"）
    return "".join(output_lines).strip() or "(empty)"

1
2
3
4
5
6
7
8

TOOLS = {
    "read": (
        "Read file with line numbers (file path, not directory)",
        {"path": "string", "offset": "number?", "limit": "number?"},
        read,
    ),
    # 其他工具配置省略...
}

1
2
3
4
5
6
7

def run_tool(name, args):
    try:
        # 从TOOLS中获取对应的工具函数并执行
        return TOOLS[name][2](args)
    except Exception as err:
        # 捕获工具执行中的所有异常，返回友好错误信息
        return f"error: {err}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

def make_schema():
    result = []
    for name, (description, params, _fn) in TOOLS.items():
        properties = {}
        required = []
        for param_name, param_type in params.items():
            # 判断参数是否可选
            is_optional = param_type.endswith("?")
            # 获取参数基础类型（去除末尾的?）
            base_type = param_type.rstrip("?")
            # 构建参数属性（number类型转为integer，适配API要求）
            properties[param_name] = {
                "type": "integer" if base_type == "number" else base_type
            }
            # 必选参数加入required列表
            if not is_optional:
                required.append(param_name)
        # 拼接单个工具的Schema
        result.append(
            {
                "name": name,
                "description": description,
                "input_schema": {
                    "type": "object",
                    "properties": properties,
                    "required": required,
                },
            }
        )
    return result

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def call_api(messages, system_prompt):
    # 构建API请求体
    request = urllib.request.Request(
        API_URL,
        data=json.dumps(
            {
                "model": MODEL,
                "max_tokens": 8192,
                "system": system_prompt,
                "messages": messages,
                "tools": make_schema(),
            }
        ).encode(),  # 转为JSON字节流
        headers={
            "Content-Type": "application/json",
            "anthropic-version": "2023-06-01",
            # 动态构建授权头：区分OpenRouter和Anthropic
            **({"Authorization": f"Bearer {OPENROUTER_KEY}"} if OPENROUTER_KEY else {"x-api-key": os.environ.get("ANTHROPIC_API_KEY", "")}),
        },
    )
    # 发送请求并获取响应
    response = urllib.request.urlopen(request)
    # 解析JSON响应为Python字典并返回
    return json.loads(response.read())

1
2
3
4
5
6
7

def separator():
    # 生成终端宽度的分隔线（最多80个字符）
    return f"{DIM}{'─' * min(os.get_terminal_size().columns, 80)}{RESET}"

def render_markdown(text):
    # 简单渲染Markdown加粗格式（**内容** → 终端加粗样式）
    return re.sub(r"\*\*(.+?)\*\*", f"{BOLD}\\1{RESET}", text)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

def main():
    # 打印程序初始化信息（名称、模型、当前工作目录）
    print(f"{BOLD}nanocode{RESET} | {DIM}{MODEL} ({'OpenRouter' if OPENROUTER_KEY else 'Anthropic'}) | {os.getcwd()}{RESET}\n")
    messages = []  # 存储对话历史
    system_prompt = f"Concise coding assistant. cwd: {os.getcwd()}"  # 系统提示词

    while True:
        try:
            # 1. 终端交互：获取用户输入
            print(separator())
            user_input = input(f"{BOLD}{BLUE}❯{RESET} ").strip()
            print(separator())
            if not user_input:
                continue
            # 退出命令
            if user_input in ("/q", "exit"):
                break
            # 清空对话历史命令
            if user_input == "/c":
                messages = []
                print(f"{GREEN}⏺ Cleared conversation{RESET}")
                continue

            # 2. 将用户输入加入对话历史
            messages.append({"role": "user", "content": user_input})

            # 3. 核心：智能体工具调用循环（直到无工具调用为止）
            while True:
                # 调用AI API获取响应
                response = call_api(messages, system_prompt)
                content_blocks = response.get("content", [])
                tool_results = []  # 存储工具执行结果

                # 解析API响应内容
                for block in content_blocks:
                    # 文本内容：直接打印到终端
                    if block["type"] == "text":
                        print(f"\n{CYAN}⏺{RESET} {render_markdown(block['text'])}")

                    # 工具调用：执行对应的工具，并收集结果
                    if block["type"] == "tool_use":
                        tool_name = block["name"]
                        tool_args = block["input"]
                        # 打印工具调用预览
                        arg_preview = str(list(tool_args.values())[0])[:50]
                        print(
                            f"\n{GREEN}⏺ {tool_name.capitalize()}{RESET}({DIM}{arg_preview}{RESET})"
                        )

                        # 执行工具并获取结果
                        result = run_tool(tool_name, tool_args)
                        # 处理结果预览，避免输出过长
                        result_lines = result.split("\n")
                        preview = result_lines[0][:60]
                        if len(result_lines) > 1:
                            preview += f" ... +{len(result_lines) - 1} lines"
                        elif len(result_lines[0]) > 60:
                            preview += "..."
                        print(f"  {DIM}⎿  {preview}{RESET}")

                        # 收集工具执行结果（用于反馈给AI）
                        tool_results.append(
                            {
                                "type": "tool_result",
                                "tool_use_id": block["id"],
                                "content": result,
                            }
                        )

                # 4. 更新对话历史：添加AI响应
                messages.append({"role": "assistant", "content": content_blocks})

                # 5. 终止循环条件：无工具调用结果（任务完成）
                if not tool_results:
                    break
                # 6. 有工具调用结果：将结果加入对话历史，继续调用AI
                messages.append({"role": "user", "content": tool_results})

            print()

        # 捕获用户中断（Ctrl+C）和EOF错误，优雅退出
        except (KeyboardInterrupt, EOFError):
            break
        # 捕获其他异常，打印友好错误信息
        except Exception as err:
            print(f"{RED}⏺ Error: {err}{RESET}")

1
2

if __name__ == "__main__":
    main()

1
2
3
4
5
6

nanocode程序架构
├── 初始化层（环境变量、常量、依赖导入）
├── 工具层（6个核心工具函数，实现具体操作）
├── 桥梁层（工具配置、Schema生成、API调用，连接工具与AI）
├── 格式层（终端输出格式优化，提升用户体验）
└── 控制层（main函数，实现交互式循环与智能体闭环）