mini-code-cli 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

mini_code_cli/agent_loop.py

@@ -0,0 +1,138 @@
+import os
+import json
+
+import prompts
+import tools
+import utils
+
+import argparse
+import sys
+
+# ANSI escape codes for colors and bold
+BOLD = '\033[1m'
+RED = '\033[91m'
+GREEN = '\033[92m'
+YELLOW = '\033[93m'
+BLUE = '\033[94m'
+MAGENTA = '\033[95m'
+CYAN = '\033[96m'
+RESET = '\033[0m'
+
+def save_history(messages):
+    # Save messages to history.json
+    with open("history.json", "w") as f:
+        json.dump(messages, f, indent=2)
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Agent loop for interacting with a language model")
+    parser.add_argument("--url", type=str, default="http://0.0.0.0:30000", help="API host")
+    parser.add_argument("--api-key", type=str, default=None, help="API key for authentication")
+    parser.add_argument("--allowed-dir", type=str, default=".", help="Allowed directory for file operations")
+    parser.add_argument("--max-tokens", type=int, default=2048, help="Maximum tokens for LLM response")
+    parser.add_argument("--temperature", type=float, default=0.0, help="Temperature for LLM")
+    parser.add_argument("--model", type=str, default="default", help="Model name")
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_args()
+
+    allowed_dir = os.path.abspath(args.allowed_dir)
+    server_url = f"{args.url}"
+
+    tools_dict = tools.util_get_tools_dict()
+    llm_tools_dict = tools.util_get_tools()
+
+    system_prompt = prompts.system_prompt(tools_dict=tools_dict, allowed_dir=allowed_dir)
+
+    messages = [{"role": "system", "content": system_prompt}]
+
+    print(f"""
+    ╔═══════════════════════════════════════════════════════════════════╗
+    ║       Coding Agent Loop Started\t\t\t\t\t║
+    ║  Type 'quit' or 'exit' to exit the loop.\t\t\t\t║
+    ║  Allowed dir: {allowed_dir}\t║    
+    ╚═══════════════════════════════════════════════════════════════════╝
+    """)
+
+    while True:
+        llm_response_flag = False
+        llm_tool_response_flag = False
+        try:
+            print("-"*30)
+            user_input = input(f"{BOLD}{CYAN}You:{RESET} ")
+            if user_input.lower() in ["quit", "exit"]:
+                print("\nThank you. Goodbye! Saving history...")
+                save_history(messages)
+                break
+        except KeyboardInterrupt:
+            print("\nThank you. Goodbye! Saving history...")
+            save_history(messages)
+            break
+
+        messages.append({"role": "user", "content": user_input})
+
+        response_text, tool_calls = utils.call_openai_server(
+            messages, 
+            max_tokens=args.max_tokens, 
+            temperature=args.temperature, 
+            model=args.model, 
+            server_url=server_url, 
+            tools=llm_tools_dict
+        )
+
+        if response_text:
+            print(f"{BOLD}{GREEN}Assistant:{RESET} {response_text}")
+            messages.append({"role": "assistant", "content": response_text})
+        else:
+            llm_response_flag = True
+
+        if tool_calls:
+            # Tool call parsing and execution
+            print(f"{BOLD}{YELLOW}Tool Call:{RESET} LLM is trying to call {len(tool_calls)} tools.")
+            if tool_calls:
+                for call in tool_calls:
+                    call_id = call.get("id", "")
+                    name = call.get("function", {}).get("name", "")
+                    params_str = call.get("function", {}).get("arguments", "{}")
+                    try:
+                        tool_params = json.loads(params_str)
+                    except json.JSONDecodeError:
+                        print(f"{BOLD}{RED}Warning:{RESET} Error parsing arguments for tool {name}")
+                        continue
+
+                    if name in tools_dict:
+                        # Check allowed directory for file operations
+                        if name in ["read_file", "write_file", "grep", "glob"]:
+                            filepath = tool_params.get("filepath", "")
+                            if name == "write_file":
+                                filepath = tool_params.get("filepath", "")
+                            if filepath and not os.path.abspath(filepath).startswith(allowed_dir):
+                                print(f"{BOLD}{RED}Warning:{RESET} File operation not allowed outside allowed directory: {allowed_dir}")
+                                continue
+
+                        func = tools_dict[name]["function"]
+                        result = func(**tool_params)
+                        # Limiting output to 300 characters for readability
+                        result_str = str(result)
+                        if len(result_str) > 300:
+                            result_str = result_str[:300] + "... (truncated to 300 chars)"
+                        print(f"{BOLD}{MAGENTA}Tool '{name}' returned:{RESET} {result_str}")
+
+                        messages.append({
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "content": str(result)
+                        })
+                    else:
+                        print(f"{BOLD}{RED}Warning:{RESET} Unknown tool: {name}")
+        else:
+            llm_tool_response_flag = True
+        
+        if llm_response_flag and llm_tool_response_flag:
+            print(f"{BOLD}{RED}Warning:{RESET} No response was given by the LLM.")
+
+        save_history(messages)
+
+if __name__ == "__main__":
+    main()

mini_code_cli/prompts.py

@@ -0,0 +1,51 @@
+# System prompt defining available tools and compaction behavior
+def system_prompt(tools_dict=None, allowed_dir=None):
+    """
+    Takes a list of tool names and returns a system prompt string.
+    """
+    allowed_dir_prompt = ""
+    if allowed_dir:
+        allowed_dir_prompt = f"\nThe path you are allowed to operate in is called: {allowed_dir}"
+    if tools_dict:
+        tool_descriptions = "\n".join([f"{name} : {data['description']}" for name, data in tools_dict.items()])
+        base_prompt = "You are a helpful AI coding assistant with access to the following tools:\n"
+        end_prompt = "\n\nWhen answering, first use available tools if needed, then provide a compact summary of the results."
+    else:
+        tool_descriptions = ""
+        base_prompt = "You are a helpful AI coding assistant without any tools."
+        end_prompt = ""
+    
+    prompt = f"""
+{base_prompt}
+{tool_descriptions}{end_prompt}{allowed_dir_prompt}
+Keep responses concise and focused.
+"""
+    return prompt.strip()
+
+def compaction_prompt(messages):
+    """
+    Takes a messages list and returns a compact prompt string summarizing the conversation.
+    """
+    conversation = "\n".join([f"{msg['role']}: {msg['content']}" for msg in messages])
+    prompt = f"""
+Please analyze the following conversation and output a concise summary covering:
+1. Key topics discussed
+2. Any decisions made
+3. Important information or facts provided
+4. Action items or next steps (if any)
+
+Keep the summary to 2-3 sentences.
+
+Conversation:
+{conversation}
+"""
+    return prompt.strip()
+
+if __name__=="__main__":
+    import tools
+    tools_dict = tools.util_get_tools_dict()
+    print(system_prompt(tools_dict))
+
+    print("="*30)
+
+    print(system_prompt())

mini_code_cli/tools.py

@@ -0,0 +1,124 @@
+import os
+import glob as glob_module
+import subprocess
+import urllib.parse
+import urllib.request
+import json
+
+def read_file(filepath):
+    """Read the contents of a file and return as a string. Param: filepath"""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+def write_file(filepath, content):
+    """Write content to a file. Overwrites if file exists. Param: filepath, content"""
+    try:
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(content)
+    except Exception as e:
+        print(f"Error: {e}")
+    return f"Wrote to file: {filepath}, content: {content}."
+
+def grep(pattern, filepath):
+    """Search for a pattern in a file using grep and return matching lines. Param: pattern, filepath"""
+    try:
+        result = subprocess.run(['grep', pattern, filepath], capture_output=True, text=True, check=False)
+        return result.stdout
+    except Exception as e:
+        return f"Error: {e}"
+
+def glob(pattern):
+    """Return list of file paths matching the given glob pattern. Param: pattern"""
+    try:
+        return glob_module.glob(pattern)
+    except Exception as e:
+        return f"Error: {e}"
+
+def web_search(query):
+    """Perform a simple web search using DuckDuckGo's API and return top results. Param: query"""
+    query_encoded = urllib.parse.quote(query)
+    url = f"https://api.duckduckgo.com/?q={query_encoded}&format=json&no_html=1"
+    try:
+        with urllib.request.urlopen(url) as response:
+            data = json.loads(response.read().decode())
+        # Extract relevant text from the response
+        results = []
+        if 'AbstractText' in data and data['AbstractText']:
+            results.append(data['AbstractText'])
+        if 'RelatedTopics' in data:
+            for topic in data['RelatedTopics']:
+                if 'Text' in topic:
+                    results.append(topic['Text'])
+        return '\n'.join(results) if results else "No results found."
+    except Exception as e:
+        return f"Error: {e}"
+
+def read_website(url):
+    """Fetch and return the text content of a given URL (simplified, returns raw HTML). Param: url"""
+    try:
+        with urllib.request.urlopen(url) as response:
+            return response.read().decode('utf-8')
+    except Exception as e:
+        return f"Error: {e}"
+
+def util_get_tools(tool_names=None):
+    """Return a JSON string describing all tool functions in this file for LLM usage."""
+    import inspect
+    tools = []
+    if tool_names:
+        func_names = [name for name, obj in globals().items() if callable(obj) and obj.__module__ == __name__ and not name.startswith('util_') and not name.startswith("_") and name in tool_names]
+    else:
+        func_names = [name for name, obj in globals().items() if callable(obj) and obj.__module__ == __name__ and not name.startswith('util_') and not name.startswith("_")]
+
+    for name in func_names:
+        func = globals()[name]
+        sig = inspect.signature(func)
+        parameters = {}
+        for param_name, param in sig.parameters.items():
+            param_type = str(param.annotation) if param.annotation != inspect.Parameter.empty else "string"
+            # Simplify common types
+            if 'int' in param_type.lower() or 'integer' in param_type.lower():
+                param_type = "integer"
+            elif 'float' in param_type.lower() or 'number' in param_type.lower():
+                param_type = "number"
+            elif 'bool' in param_type.lower():
+                param_type = "boolean"
+            elif 'list' in param_type.lower() or 'array' in param_type.lower():
+                param_type = "array"
+            else:
+                param_type = "string"
+            parameters[param_name] = {"type": param_type}
+        tool = {
+            "type": "function",
+            "function": {
+                "name": name,
+                "description": func.__doc__ if func.__doc__ else f"Function {name}",
+                "parameters": {
+                    "type": "object",
+                    "properties": parameters,
+                    "required": [p for p in sig.parameters if sig.parameters[p].default == inspect.Parameter.empty]
+                }
+            }
+        }
+        tools.append(tool)
+    return tools
+
+
+def util_get_tools_dict():
+    """Return a dictionary mapping tool names to their function objects."""
+    result = {}
+    func_names = [name for name, obj in globals().items() if callable(obj) and obj.__module__ == __name__ and not name.startswith('util_') and not name.startswith("_")]
+    for name in func_names:
+        func = globals()[name]
+        desc = func.__doc__ if func.__doc__ else f"Function {name}"
+        result[name] = {"function": func, "description": desc}
+    return result
+
+
+if __name__=="__main__":
+    # print(util_get_tools())
+    print(json.dumps(tools_dict, indent=4))

mini_code_cli/utils.py

@@ -0,0 +1,111 @@
+import requests
+import json
+import argparse
+
+
+def call_openai_server(messages, max_tokens=2048, temperature=0.0, top_p=0.95, model="default", server_url=None, api_key=None, tools=None,):
+    """
+    Querying an OpenAI-compatible server (local or remote) using the requests library.
+    Supports authentication via API key if provided.
+    """
+    url = f"{server_url}/v1/chat/completions"
+
+    headers = {
+        "Content-Type": "application/json"
+    }
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    payload = {
+        "model": model,
+        "messages": messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "top_p": top_p
+    }
+
+    if tools:
+        payload["tools"] = tools
+        payload["tool_choice"] = "auto"
+
+    try:
+        response = requests.post(
+            url,
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        response.raise_for_status()
+
+        result = response.json().get("choices", [{}])[0].get("message", {})
+        content = result.get("content", "")
+        tool_calls = result.get("tool_calls", [])
+
+        return content, tool_calls
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error calling OpenAI Server...: {e}")
+        return None, None
+    except (json.JSONDecodeError, KeyError, IndexError) as e:
+        print(f"Error processing response: {e}")
+        return None, None
+
+# Alternative: use the newer SGLang API format (v0.3+)
+def call_openai_server_prompt(prompt, max_tokens=1024, temperature=0.0, top_p=0.95, model="default", server_url=None, api_key=None, tools=None):
+    """
+    OpenAI compatible call, pre-creating the messages object.
+    """
+    messages = [
+            {"role": "user", "content": prompt}
+        ]
+
+    return call_openai_server(messages, max_tokens, temperature, top_p, model, server_url=server_url, api_key=api_key, tools=tools)
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Agent loop for interacting with a language model")
+    parser.add_argument("--host", type=str, default="localhost", help="API host")
+    parser.add_argument("--port", type=int, default=30000, help="API port")
+    parser.add_argument("--prompt", type=str, default="What is the purpose of life?", help="prompt")
+    parser.add_argument("--api-key", type=str, default=None, help="API key for authentication (optional)")
+
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    import tools
+    tools_dict = tools.util_get_tools()
+
+    args = parse_args()
+    # Configuration for local SGLang deployment
+    server_url=f"http://{args.host}:{args.port}" 
+
+    print("="*60)
+    print("Entering LLM call:")
+    print("-"*30)
+    prompt = args.prompt
+
+    print(f"Prompt:\n{prompt}")
+    print("---")
+ 
+    response_text, tool_calls = call_openai_server_prompt(prompt, server_url=server_url, api_key=args.api_key, tools=tools_dict)
+    print(f"Response:\n{response_text}")
+    print("---")
+    print(f"Tools:\n{tool_calls}")
+    print("---")
+
+
+
+    # #################################
+    # Test call to DeepSeek endpoint
+    # #################################
+
+    # deepseek_server_url = "https://api.deepseek.com"
+    # deepseek_model = "deepseek-v4-flash"
+    # print("="*60)
+    # print("Entering DeepSeek call:")
+    # print("-"*30)
+    # response_text_ds, tools_ds = call_openai_server_prompt(prompt, server_url=deepseek_server_url, api_key=args.api_key, model=deepseek_model, tools=tools_dict)
+    # print(f"DeepSeek Response:\n{response_text_ds}")
+    # print("---")
+    # print(f"Tools:\n{tools_ds}")
+    # print("---")

{mini_code_cli-0.0.2.dist-info → mini_code_cli-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.0.2
+Version: 0.0.4
 Summary: Minimal Coding CLI
 Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
 License: The MIT License (MIT)
@@ -30,8 +30,8 @@ pip3 install mini-code-cli
 
 2. Run agent: (get LLM running via SGLang or Vllm)
 ```bash
-mini_code_cli #run the agent loop
-mini_code_cli --url "0.0.0.0" --allowed-dir ./experiments/ --api-key "sk-dummy" #localhost and 30000 is default, allowed_dir ./ is default
+mini-code #run the agent loop
+mini-code --url "https://api.deepseek.com" --model "deepseek-v4-flash" --api-key "sk-dummy" --allowed-dir ./experiments/
 ```
 
 

mini_code_cli-0.0.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+mini_code_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mini_code_cli/agent_loop.py,sha256=uuAeiqbiy3PE3r8Vs_dDkcbDKVmcxkefhUdXbWifPzE,5683
+mini_code_cli/prompts.py,sha256=bMWPLsD0SCQK4oDru4MYSSUf2KQq8EO4ZD55PpdlR_I,1730
+mini_code_cli/tools.py,sha256=i46l8IvsrXJgqt7r8rKAMTGKNGAGffxKTFlwmAuWoD0,4926
+mini_code_cli/utils.py,sha256=KmI-hfVsuopVRr5lLXiW2T24RZawtGKHOy9n8Ak1UC4,3636
+mini_code_cli-0.0.4.dist-info/licenses/LICENSE,sha256=WCkMINUFi--UtEg_alEE2FBKPtNKkzi7dGzaxzchifc,1088
+mini_code_cli-0.0.4.dist-info/METADATA,sha256=thK7lq5Z6h2h934eeFcBpzWgV-LH9Q4p4YdO411fMpg,1943
+mini_code_cli-0.0.4.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mini_code_cli-0.0.4.dist-info/entry_points.txt,sha256=MwDp5UbXpI7wodSmOSYL8_nKutnBiyp96ZDDtaX7x14,60
+mini_code_cli-0.0.4.dist-info/top_level.txt,sha256=3Hb6PpNkJYXvzDKXuuFJRvzCdsTRh0TuRWz-ScJ6qV0,14
+mini_code_cli-0.0.4.dist-info/RECORD,,

mini_code_cli-0.0.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mini-code = mini_code_cli.agent_loop:main

mini_code_cli-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+mini_code_cli

mini_code_cli-0.0.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-mini_code_cli-0.0.2.dist-info/licenses/LICENSE,sha256=WCkMINUFi--UtEg_alEE2FBKPtNKkzi7dGzaxzchifc,1088
-mini_code_cli-0.0.2.dist-info/METADATA,sha256=SccCYdxuHXjx1ASjSn3fZnvy3fOxQr3E6S0O1e9fp0s,1965
-mini_code_cli-0.0.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-mini_code_cli-0.0.2.dist-info/entry_points.txt,sha256=ZPwaUZnKtV8ZwNPZPoocL-y2x6gkb3ZN5tYDlsNRIng,53
-mini_code_cli-0.0.2.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-mini_code_cli-0.0.2.dist-info/RECORD,,

mini_code_cli-0.0.2.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-mini-code-cli = mini_code_cli:main

mini_code_cli-0.0.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-