Commit 181c11e

package main

import "fmt"

func fizzbuzz(n int) {

for i := 1; i <= n; i++ {

switch {

case i%15 == 0:

fmt.Println("FizzBuzz")

case i%3 == 0:

fmt.Println("Fizz")

case i%5 == 0:

fmt.Println("Buzz")

default:

fmt.Println(i)

}

}

}

func main() {

// Execute FizzBuzz for numbers 1 to 15

fizzbuzz(15)

}

function fizzbuzz(n) {

for (let i = 1; i <= n; i++) {

if (i % 15 === 0) {

console.log('FizzBuzz');

} else if (i % 3 === 0) {

console.log('Fizz');

} else if (i % 5 === 0) {

console.log('Buzz');

} else {

console.log(i);

}

}

import os

import sys

from openai import OpenAI

from dotenv import load_dotenv

import json

from utils.console import Console

from tools import ToolDefinition, read_file_tool, list_files_tool, edit_file_tool

load_dotenv()

api_key = os.environ.get("DEEPSEEK_API_KEY")

if not api_key:

Console.error("DEEPSEEK_API_KEY not found in .env")

sys.exit(1)

client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com/")

MODEL = "deepseek-chat"

class Agent:

def __init__(self, client_instance, tool_definitions: list[ToolDefinition] = []):

self.client = client_instance

self.tool_definitions = {tool.name: tool for tool in tool_definitions} # Convert to dict for faster lookup

def execute_tool_call(self, tool_call):

try:

tool_name = tool_call.function.name

tool_args_str = tool_call.function.arguments

if tool_name not in self.tool_definitions:

return f"Error: Tool '{tool_name}' not found"

tool_args = json.loads(tool_args_str)

result = self.tool_definitions[tool_name].function(**tool_args)

return result

except Exception as e:

return f"Error processing tool call: {str(e)}"

def run_inference(self, conversation_history):

try:

response = self.client.chat.completions.create(

model=MODEL,

messages=conversation_history,

max_tokens=1024,

tools=[tool.get_api_description() for tool in self.tool_definitions.values()],

)

return response.choices[0].message

except Exception as e:

Console.error(f"API Error: {e}")

return None

def run(self):

conversation = []

Console.info(f"Chatting with {MODEL}. Hit Ctrl+C to exit.")

while True:

try:

user_input = Console.user("")

if not user_input:

continue

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

while True:

assistant_message_obj = self.run_inference(conversation)

if not assistant_message_obj:

if conversation and conversation[-1]["role"] == "user":

conversation.pop()

break

assistant_message = assistant_message_obj.model_dump(exclude_unset=True)

conversation.append(assistant_message)

if assistant_message_obj.content:

Console.assistant(MODEL, assistant_message_obj.content)

if assistant_message_obj.tool_calls:

tool_call_responses = []

for tool_call in assistant_message_obj.tool_calls:

Console.tool_call(tool_call.function.name, tool_call.function.arguments)

tool_result = self.execute_tool_call(tool_call)

tool_response = {

"role": "tool",

"tool_call_id": tool_call.id,

"name": tool_call.function.name,

"content": str(tool_result)

}

conversation.append(tool_response)

tool_call_responses.append(tool_response)

continue

break

except KeyboardInterrupt:

Console.info("\nExiting...")

break

Console.info("Agent run() finished.")

if __name__ == "__main__":

agent_instance = Agent(client_instance=client, tool_definitions=[read_file_tool, list_files_tool, edit_file_tool])

agent_instance.run()

from .tool_definition import ToolDefinition

from .file_operations import read_file_from_path, list_files_from_path, edit_file

read_file_tool = ToolDefinition(

name="read_file",

description="Read the contents of a file",

parameters={

"type": "object",

"properties": {

"file_path": {

"type": "string",

"description": "Path to the file to read"

}

},

"required": ["file_path"]

},

function_to_call=read_file_from_path

)

list_files_tool = ToolDefinition(

name="list_files",

description="List files and directories at a given path. If no path is provided, lists files in the current directory.",

parameters={

"type": "object",

"properties": {

"path": {

"type": "string",

"description": "Optional relative path to list files from. Defaults to current directory if not provided."

}

}

},

function_to_call=list_files_from_path

)

edit_file_tool = ToolDefinition(

name="edit_file",

description="Make edits to a text file. Replaces 'old_str' with 'new_str' in the given file. 'old_str' and 'new_str' MUST be different from each other. If the file specified with path doesn't exist, it will be created.",

parameters={

"type": "object",

"properties": {

"path": {

"type": "string",

"description": "The path to the file"

},

"old_str": {

"type": "string",

"description": "Text to search for - must match exactly and must only have one match exactly"

},

"new_str": {

"type": "string",

"description": "Text to replace old_str with"

}

},

"required": ["path", "old_str", "new_str"]

},

function_to_call=edit_file

)

import os

import json

def read_file_from_path(file_path: str) -> str:

try:

with open(file_path, 'r', encoding='utf-8') as f:

content = f.read()

return content

except FileNotFoundError:

raise FileNotFoundError(f"Error: File not found at path: {file_path}")

except Exception as e:

raise Exception(f"An error occurred while reading the file '{file_path}': {e}")

def list_files_from_path(path: str = ".") -> str:

try:

file_list = []

for root, dirs, files in os.walk(path):

if root == path:

for d in dirs:

file_list.append(f"{d}/")

for f in files:

file_list.append(f)

else:

rel_path = os.path.relpath(root, path)

for d in dirs:

file_list.append(f"{rel_path}/{d}/")

for f in files:

file_list.append(f"{rel_path}/{f}")

return json.dumps(file_list)

except Exception as e:

raise Exception(f"An error occurred while listing files at path '{path}': {e}")

def create_new_file(file_path: str, content: str) -> str:

dir_path = os.path.dirname(file_path)

if dir_path and dir_path != ".":

os.makedirs(dir_path, exist_ok=True)

with open(file_path, 'w', encoding='utf-8') as f:

f.write(content)

return f"Successfully created file {file_path}"

def edit_file(path: str, old_str: str, new_str: str) -> str:

if path == "" or old_str == new_str:

raise ValueError("Invalid input parameters")

try:

try:

with open(path, 'r', encoding='utf-8') as f:

old_content = f.read()

if old_str == "":

raise FileNotFoundError() # Treat empty old_str as file not found for creation logic

new_content = old_content.replace(old_str, new_str)

if old_content == new_content and old_str != "":

raise ValueError("old_str not found in file")

with open(path, 'w', encoding='utf-8') as f:

f.write(new_content)

return f"Successfully edited file {path}"

except FileNotFoundError:

if old_str == "": # If old_str is empty and file not found, create new file

return create_new_file(path, new_str)

raise

except Exception as e:

raise Exception(f"An error occurred while editing the file '{path}': {e}")

import typing

class ToolDefinition:

def __init__(self, name: str, description: str, parameters: dict, function_to_call: typing.Callable):

self.name = name

self.description = description

self.parameters = parameters

self.function = function_to_call

def get_api_description(self) -> dict:

return {

"type": "function",

"function": {

"name": self.name,

"description": self.description,

"parameters": self.parameters,

}

}