export ANTHROPIC_API_KEY=you_need_a_key
uv init indubitably-code
cd indubitably-code
uv venv
source

# main.py
import os
import sys
from anthropic import Anthropic

def main():
    client = Anthropic()  # reads ANTHROPIC_API_KEY
    conversation = []     # list[dict]: [{"role":"user"/"assistant","content":[...]}]

    print("Chat with Claude (ctrl-c to quit)")
    for line in sys.stdin:
        user_text = line.rstrip("\n")
        conversation.append({"role": "user", "content": [{"type": "text", "text": user_text}]})

        msg = client.messages.create(
            model="claude-3-7-sonnet-latest",
            max_tokens=1024,
            messages=conversation,
        )
        # append assistant turn to keep stateless API “stateful”
        conversation.append({"role": "assistant", "content": msg.content})

        # print any text blocks
        for block in msg.content:
            if block.type == "text":
                print(f"Claude: {block.text}")

if __name__ == "__main__":
    main()

# agent.py
import json
import sys
from typing import Callable, Dict, Any, List
from anthropic import Anthropic

ToolFunc = Callable[[Dict[str, Any]], str]

class Tool:
    def __init__(self, name: str, description: str, input_schema: Dict[str, Any], fn: ToolFunc):
        self.name = name
        self.description = description
        self.input_schema = input_schema
        self.fn = fn

def run_agent(tools: List[Tool]):
    client = Anthropic()
    conversation: List[Dict[str, Any]] = []

    print("Chat with Claude (ctrl-c to quit)")
    read_user = True

    while True:
        if read_user:
            line = sys.stdin.readline()
            if not line:
                break
            conversation.append({"role": "user", "content": [{"type": "text", "text": line.rstrip('\n')}]})

        # prepare Anthropic tool definitions
        tool_defs = [{
            "name": t.name,
            "description": t.description,
            "input_schema": t.input_schema,
        } for t in tools]

        msg = client.messages.create(
            model="claude-3-7-sonnet-latest",
            max_tokens=1024,
            messages=conversation,
            tools=tool_defs,  # enabling tool use
        )

        conversation.append({"role": "assistant", "content": msg.content})

        tool_results_content: List[Dict[str, Any]] = []
        for block in msg.content:
            if block.type == "text":
                print(f"Claude: {block.text}")
            elif block.type == "tool_use":
                tool_name = block.name
                tool_input = block.input  # already a dict
                tool_use_id = block.id

                # dispatch
                impl = next((t for t in tools if t.name == tool_name), None)
                if impl is None:
                    tool_results_content.append({
                        "type": "tool_result",
                        "tool_use_id": tool_use_id,
                        "content": "tool not found",
                        "is_error": True,
                    })
                else:
                    try:
                        result_str = impl.fn(tool_input)
                        tool_results_content.append({
                            "type": "tool_result",
                            "tool_use_id": tool_use_id,
                            "content": result_str,
                            "is_error": False,
                        })
                    except Exception as e:
                        tool_results_content.append({
                            "type": "tool_result",
                            "tool_use_id": tool_use_id,
                            "content": str(e),
                            "is_error": True,
                        })

        if not tool_results_content:
            read_user = True
            continue

        # send tool results back as a user message and loop again
        conversation.append({"role": "user", "content": tool_results_content})
        read_user = False

# tools_read.py
import os
from typing import Dict, Any

def read_file_tool_def():
    return {
        "name": "read_file",
        "description": "Read the contents of a given relative file path. Use for file contents. Not for directories.",
        "input_schema": {
            "type": "object",
            "additionalProperties": False,
            "properties": {
                "path": {
                    "type": "string",
                    "description": "Relative path to a file in the working directory."
                }
            },
            "required": ["path"]
        }
    }

def read_file_impl(input: Dict[str, Any]) -> str:
    path = input.get("path", "")
    if not path:
        raise ValueError("missing 'path'")
    with open(path, "r", encoding="utf-8") as f:
        return f.read()

# tools_list.py
import os
from typing import Dict, Any, List

def list_files_tool_def():
    return {
        "name": "list_files",
        "description": "List files and directories at a given path. If path omitted, list current directory.",
        "input_schema": {
            "type": "object",
            "additionalProperties": False,
            "properties": {
                "path": {
                    "type": "string",
                    "description": "Optional relative path. Defaults to current directory."
                }
            }
        }
    }

def list_files_impl(input: Dict[str, Any]) -> str:
    start = input.get("path") or "."
    results: List[str] = []
    for root, dirs, files in os.walk(start):
        # make root relative to 'start'
        rel_root = os.path.relpath(root, start)
        def append_entry(name, is_dir):
            rel_path = name if rel_root == "." else os.path.join(rel_root, name)
            results.append(rel_path + ("/" if is_dir else ""))
        for d in dirs:
            append_entry(d, True)
        for f in files:
            append_entry(f, False)
    import json
    return json.dumps(results)

# tools_edit.py
import os
from pathlib import Path
from typing import Dict, Any

def edit_file_tool_def():
    return {
        "name": "edit_file",
        "description": (
            "Make edits to a text file.\n"
            "Replaces 'old_str' with 'new_str' in the given file. "
            "'old_str' and 'new_str' MUST be different. "
            "If the file does not exist and old_str == '', the file is created with new_str."
        ),
        "input_schema": {
            "type": "object",
            "additionalProperties": False,
            "properties": {
                "path": {"type": "string", "description": "The path to the file"},
                "old_str": {"type": "string", "description": "Exact text to replace (must match exactly)"},
                "new_str": {"type": "string", "description": "Replacement text"}
            },
            "required": ["path", "old_str", "new_str"]
        }
    }

def _create_new_file(file_path: str, content: str) -> str:
    p = Path(file_path)
    p.parent.mkdir(parents=True, exist_ok=True)
    p.write_text(content, encoding="utf-8")
    return f"Successfully created file {file_path}"

def edit_file_impl(input: Dict[str, Any]) -> str:
    path = input.get("path", "")
    old = input.get("old_str", None)
    new = input.get("new_str", None)

    if not path or old is None or new is None or old == new:
        raise ValueError("invalid input parameters")

    if not os.path.exists(path):
        if old == "":
            return _create_new_file(path, new)
        raise FileNotFoundError(path)

    content = Path(path).read_text(encoding="utf-8")
    if old == "":
        # create-only behavior when old == ""
        Path(path).write_text(new, encoding="utf-8")
        return "OK"

    new_content = content.replace(old, new)
    if new_content == content:
        raise ValueError("old_str not found in file")

    Path(path).write_text(new_content, encoding="utf-8")
    return "OK"

# run.py
from agent import run_agent, Tool
from tools_read import read_file_tool_def, read_file_impl
from tools_list import list_files_tool_def, list_files_impl
from tools_edit import edit_file_tool_def, edit_file_impl

if __name__ == "__main__":
    tools = [
        Tool(**read_file_tool_def(), fn=read_file_impl),
        Tool(**list_files_tool_def(), fn=list_files_impl),
        Tool(**edit_file_tool_def(), fn=edit_file_impl),
    ]
    run_agent(tools)

uv run run.py
# then try:
# what's in main.py?
# what do you see in this directory?
# hey claude, create fizzbuzz.js that I can run with Nodejs and that has fizzbuzz in it and executes it
# Please edit fizzbuzz.js so that it only prints until 15

uv run main.py
# Classic chatbot in the terminal