mini-code-cli 0.0.7__py3-none-any.whl → 0.0.8.0__py3-none-any.whl

mini_code_cli/__init__.py

@@ -0,0 +1,2 @@
+from importlib.metadata import version
+__version__ = version("mini-code-cli")

mini_code_cli/agent_loop.py

@@ -1,5 +1,17 @@
+"""
+Usage:
+    mini-code
+
+Prompt:
+
+write a similar model.py file but for a LSTM based language model. Make it minimal and call it model_lstm.py it should still be compatible with eval.py
+
+"""
+
 import os
 import json
+import signal
+
 
 from . import prompts
 from . import tools
@@ -26,23 +38,44 @@ def save_history(messages):
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Agent loop for interacting with a language model")
+    # MODEL / LLM related
     parser.add_argument("--url", type=str, default="http://0.0.0.0:30000", help="API host")
-    parser.add_argument("--system_prompt", type=str, 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, 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")
+    parser.add_argument("--api-key", type=str, default=None, help="API key for authentication. If not set, it tries to find it in env variable: MINI_CODE_API_KEY.")
+
+    # Agent behaviour related
+    parser.add_argument("--system-prompt", type=str, help="Replace system prompt, with a custom system prompt.")
+    parser.add_argument("--auto-mode", action="store_true", help="Whether to run the agent in `auto-mode'. Or default: `manual-mode'.")
+    parser.add_argument("--agent-md", type=str, help="If the agent should use an agent-md file... (it will added after system message.)")
+
+    # Agent permissions related
+    parser.add_argument("--ask-permission", action="store_true", help="Ask for permission before any tool call.")
+    parser.add_argument("--allowed-dir", type=str, default=".", help="Allowed directory for file operations")
+    parser.add_argument("--enable-shell", action="store_true", help="Allow shell execution. Default: False") #todo
+
+
     args = parser.parse_args()
     return args
 
-def print_welcome(allowed_dir, server_url):
+
+def print_welcome(allowed_dir, server_url, args):
     # Calculate the length of the longest line inside the box
+    version = __import__('mini_code_cli').__version__
+    
+    permission_mode = "All tool calls require permission." if args.ask_permission else "Tool calls will execute without asking for permission."
+    agent_mode = "Agent is in manual-mode." if not args.auto_mode else "Agent is in auto-mode."
+    shell_mode = "Shell disabled." if not args.enable_shell else "Shell enabled."
+
     lines = [
-        "       Coding Agent Loop Started",
-        "  Type 'quit' or 'exit' to exit the loop.",
+        f"  MiniCodeCLI (v{version})",
+         "  Type 'quit' or 'exit' to exit the loop.",
         f"  Allowed dir: {allowed_dir}",
-        f"  Server URL: {server_url}"
+        f"  Server URL: {server_url}",
+        f"  {permission_mode}",
+        f"  {agent_mode}",
+        f"  {shell_mode}"
     ]
     max_len = max(len(line) for line in lines)
     margin = 2  # Space on each side inside the box
@@ -57,15 +90,66 @@ def print_welcome(allowed_dir, server_url):
     bottom = "╚" + "═" * inner_width + "╝"
     print(bottom)
 
+def print_help(allowed_dir, server_url, args):
+    print_welcome(allowed_dir, server_url, args)
+    
+    help_message = ""
+    help_message += "Manual-mode means the agent will ask for user input after each LLM prediction." if not args.auto_mode else "Auto-mode means the agent will keep calling the LLM until no further LLM calls are possible."
+
+    print(f"{BOLD}{GREEN}HELP:{RESET} {help_message}")
+
+def call_function_with_timeout(func, tool_params, name):
+    """calls function with params"""
+    class TimeoutError(Exception):
+        pass
+
+    def timeout_handler(signum, frame):
+        raise TimeoutError("Function call timed out")
+
+    timeout_seconds = 30  # Set your desired timeout in seconds
+    signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(timeout_seconds)
+    try:
+        result = func(**tool_params)
+    except TimeoutError:
+        print(f"{BOLD}{RED}Error:{RESET} Function {name} timed out after {timeout_seconds} seconds.")
+        result = "Error:Function {name} timed out after {timeout_seconds} seconds."
+    finally:
+        signal.alarm(0)  # Disable the alarm
+    
+    return result
+
 def main():
     args = parse_args()
 
-    allowed_dir = os.path.abspath(args.allowed_dir)
+
+    # LLM Related
     server_url = f"{args.url}"
+    api_key = None
+    if args.api_key:
+        api_key = args.api_key
+    else:
+        api_key = os.environ.get("MINI_CODE_API_KEY", "")
+        if api_key:
+            print(f"{YELLOW}API Key found at MINI_CODE_API_KEY{RESET}")
+        else:
+            print(f"{YELLOW}NO API Key found at MINI_CODE_API_KEY. Set it with export MINI_CODE_API_KEY='sk-api-key'{RESET}")
 
-    tools_dict = tools.util_get_tools_dict()
-    llm_tools_dict = tools.util_get_tools()
+    
+    # Permissions related
+    allowed_dir = os.path.abspath(args.allowed_dir)
 
+    if not args.enable_shell:
+        forbidden_tools = tools.shell_tools
+    else:
+        forbidden_tools = None
+
+    # TOOLs
+    tools_dict = tools.util_get_tools_dict(forbidden_tools=forbidden_tools)
+    llm_tools_dict = tools.util_get_tools(forbidden_tools=forbidden_tools)
+
+
+    # System Message and Agent.md
     if args.system_prompt:
         system_prompt = args.system_prompt
     else:
@@ -73,24 +157,59 @@ def main():
 
     messages = [{"role": "system", "content": system_prompt}]
 
-    print_welcome(allowed_dir, server_url)
+    if args.agent_md:
+        print(f"{YELLOW}AGENT.md '{args.agent_md}' specified.{RESET}")
+
+        # Check if the file exists
+        if not os.path.isfile(args.agent_md):
+            print(f"{RED}Error: The AGENT.md '{args.agent_md}' does not exist.{RESET}")
+        else:
+            # Load the content of agent-md file and add it after system message
+            with open(args.agent_md, 'r', encoding='utf-8') as f:
+                agent_md_content = f.read()
+            print(f"{YELLOW}AGENT.md '{args.agent_md}' loaded.{RESET}")
+
+        # Append the content as a user message after the system prompt
+        messages.append({"role": "user", "content": agent_md_content})
 
+    print_welcome(allowed_dir, server_url, args)
+
+    # Agent Logic Flags
+    llm_response_flag = False
+    llm_tool_response_flag = False
+    llm_repeat_flag = False
+    tool_count = 0
+    
     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"]:
+        if llm_tool_response_flag and args.auto_mode: #skip user input and try to call the model again until there no more tool calls.
+            print(f"{BOLD}{YELLOW}System:{RESET} Skipping user input. Continuing with LLM calls until no more tool calls. [Tool count={tool_count}]")
+            llm_repeat_flag = True
+        else:
+        # get user input
+            if llm_repeat_flag:
+                print(f"{BOLD}{YELLOW}System:{RESET} Called {tool_count} tools in total. Exiting tool loop.")
+
+            tool_count = 0
+            try:
+                print("-"*30)
+                user_input = input(f"{BOLD}{CYAN}You:{RESET} ")
+                if user_input.lower() in ["quit", "exit", "/quit", "/exit"]:
+                    print("\nThank you. Goodbye! Saving history...")
+                    save_history(messages)
+                    break
+            except KeyboardInterrupt:
                 print("\nThank you. Goodbye! Saving history...")
                 save_history(messages)
                 break
-        except KeyboardInterrupt:
-            print("\nThank you. Goodbye! Saving history...")
-            save_history(messages)
-            break
+            
+            if user_input == "/help":
+                print_help(allowed_dir, server_url, args)
+                continue
 
-        messages.append({"role": "user", "content": user_input})
+            messages.append({"role": "user", "content": user_input})
+
+        llm_response_flag = False
+        llm_tool_response_flag = False
 
         response_text, tool_calls = utils.call_openai_server(
             messages, 
@@ -98,20 +217,28 @@ def main():
             temperature=args.temperature, 
             model=args.model, 
             server_url=server_url, 
-            tools=llm_tools_dict
+            tools=llm_tools_dict,
+            api_key=api_key,
         )
 
         if response_text:
-            print(f"{BOLD}{GREEN}Assistant:{RESET} {response_text}")
-            messages.append({"role": "assistant", "content": response_text})
-        else:
             llm_response_flag = True
+            print(f"{BOLD}{GREEN}Assistant:{RESET} {response_text}")
 
         if tool_calls:
+            llm_tool_response_flag = True
+            
+            messages.append({
+                    "role": "assistant",
+                    "content": response_text,
+                    "tool_calls": tool_calls
+            })
             # Tool call parsing and execution
             print(f"{BOLD}{YELLOW}Tool Call:{RESET} LLM is trying to call {len(tool_calls)} tools.")
 
             for call in tool_calls:
+                tool_count += 1
+
                 call_id = call.get("id", "")
                 name = call.get("function", {}).get("name", "")
                 params_str = call.get("function", {}).get("arguments", "{}")
@@ -132,7 +259,27 @@ def main():
                             continue
 
                     func = tools_dict[name]["function"]
-                    result = func(**tool_params)
+                    # asking permissions
+                    if args.ask_permission:
+                        print(f"{BOLD}{YELLOW}Tool permission:{RESET} Are you sure you want to call the tool?")
+                        print(f"name: {name}, parameters: {params_str}")
+                        try:
+                            permission_input = input("Type: 'y' or 'yes'\n")
+                        except KeyboardInterrupt:
+                            print("\nThank you. Goodbye! Saving history...")
+                            save_history(messages)
+                            sys.exit(0)
+
+                        if not permission_input in ['y', 'yes']:
+                            print(f"{BOLD}{YELLOW}Tool permission denied:{RESET}.")
+                            messages.append({
+                                "role": "user",
+                                "content": f"User denied permission for tool {name} and params {params_str}."
+                            })
+                            continue
+
+                    print(f"{BOLD}{YELLOW}Tool Call:{RESET} LLM is trying to call: {name} with {tool_params}.")
+                    result = call_function_with_timeout(func, tool_params, name)
                     # Limiting output to 300 characters for readability
                     result_str = str(result)
                     if len(result_str) > 300:
@@ -145,11 +292,15 @@ def main():
                         "content": str(result)
                     })
                 else:
-                    print(f"{BOLD}{RED}Warning:{RESET} Unknown tool: {name}")
+                    print(f"{BOLD}{RED}Warning:{RESET} Unknown tool: {name}, params {params_str}")
         else:
-            llm_tool_response_flag = True
+            messages.append({
+                    "role": "assistant",
+                    "content": response_text,
+                    # "tool_calls": tool_calls
+            })
         
-        if llm_response_flag and llm_tool_response_flag:
+        if not llm_response_flag and not llm_tool_response_flag:
             print(f"{BOLD}{RED}Warning:{RESET} No response was given by the LLM.")
 
         save_history(messages)

mini_code_cli/tools.py

@@ -65,14 +65,27 @@ def read_website(url):
     except Exception as e:
         return f"Error: {e}"
 
-def util_get_tools(tool_names=None):
+def run_shell_command(command):
+    """Run a shell command and return its output. Param: command (string)"""
+    try:
+        result = subprocess.run(command, shell=True, capture_output=True, text=True, check=False)
+        output = result.stdout
+        if result.stderr:
+            output += "\nSTDERR:\n" + result.stderr
+        return output
+    except Exception as e:
+        return f"Error: {e}"
+
+def util_get_tools(allowed_tools=None, forbidden_tools=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("_")]
+    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("_")]
+    
+    if allowed_tools:
+        func_names = [name for name in func_names if name in allowed_tools]
+    if forbidden_tools:
+        func_names = [name for name in func_names if name not in forbidden_tools]
 
     for name in func_names:
         func = globals()[name]
@@ -108,17 +121,25 @@ def util_get_tools(tool_names=None):
     return tools
 
 
-def util_get_tools_dict():
+def util_get_tools_dict(allowed_tools=None, forbidden_tools=None):
     """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("_")]
+    if allowed_tools:
+        func_names = [name for name in func_names if name in allowed_tools]
+    if forbidden_tools:
+        func_names = [name for name in func_names if name not in forbidden_tools]
+
     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
 
+shell_tools = [
+    "run_shell_command"
+]
 
 if __name__=="__main__":
-    # print(util_get_tools())
-    print(json.dumps(tools_dict, indent=4))
+    print(util_get_tools())
+    # print(json.dumps(tools_dict, indent=4))

{mini_code_cli-0.0.7.dist-info → mini_code_cli-0.0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.0.7
+Version: 0.0.8.0
 Summary: Minimal Coding CLI
 Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
 License: The MIT License (MIT)
@@ -20,18 +20,48 @@ Dynamic: license-file
 
 # A minimal coding agent cli
 
-Purpose: no bloat, minimal coding cli, to enjoy experimenting and researching things...
+> No bloat, no dependencies, no tracking, no telemetry...
+
+Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
 
 ## Getting started:
-1. Installation (from pypi)
+
+### Installation (from pypi)
 ```bash
 pip3 install mini-code-cli
 ```
 
-2. Run agent: (get LLM running via SGLang or Vllm)
+### Run agent:
+
+1. Basic usage: (get local LLM running (e.g. via SGLang or Vllm))
+```bash
+mini-code #run the agent using `localhost:30000/v1` model
+```
+2. Custom API based model:
+```bash
+export MINI_CODE_API_KEY="sk-YOUR_API_KEY"
+mini-code --url "https://api.deepseek.com" --model "deepseek-v4-flash"
+```
+
+Auto-mode, Agent.md, Shell Enabled mode and a specific allowed dir:
+```bash
+mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./" --ask-permission --system-prompt "Your awesome new system prompt..."
+```
+- auto-mode: the agent will continue querying the LLM and executing tools, until no more tool calls are possible
+- agent.md: this will read an agent.md file with the specified name (e.g. ./skill.md)
+- shell-enabled: **Be careful**: This will allow the agent to execute shell commands. Specifically, there is no permission checks.
+- allowed-dir: this specifies which dirs the agent can read and write from, that does not stop the shell comands!
+- ask-permission: asks user permission before every tool call.
+- system-prompt: you can override the default prompt by using a string. (Not Agent.md is always appended after the system prompt.)
+
+3. Try a prompt:
+```txt
+Write an agent.md file for me that helps an LLM write efficient triton kernels, given a reference implementation.
+```
+
+4. Get help:
 ```bash
-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 --help
 ```
 
 

mini_code_cli-0.0.8.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+mini_code_cli/__init__.py,sha256=iNgHmKSHOuH99obGjnUMoS2JP4Gw4AOrIfu68EYaZQM,77
+mini_code_cli/agent_loop.py,sha256=m2X-53-0oM7ZJTZRzXHOurofcqdUXkr5W0xiRKXkZkg,12130
+mini_code_cli/prompts.py,sha256=1dY5f7pSvfDnjhA-uDmi0Rw66_JFQGfooF699pATO0E,1985
+mini_code_cli/tools.py,sha256=R8DWRu0zij2Xwioldd6tDeMtVfSaZhqcWAsjvskOxvw,5627
+mini_code_cli/utils.py,sha256=HlmuLH0V4AxZTg0_ZGzlxffqRqs7T3W6FQXaBhioGdk,3647
+mini_code_cli-0.0.8.0.dist-info/licenses/LICENSE,sha256=WCkMINUFi--UtEg_alEE2FBKPtNKkzi7dGzaxzchifc,1088
+mini_code_cli-0.0.8.0.dist-info/METADATA,sha256=njKXtDgl-aLKarbmgJ8TxHWFh6Olj3vY8dBCCmxUy4w,3146
+mini_code_cli-0.0.8.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mini_code_cli-0.0.8.0.dist-info/entry_points.txt,sha256=MwDp5UbXpI7wodSmOSYL8_nKutnBiyp96ZDDtaX7x14,60
+mini_code_cli-0.0.8.0.dist-info/top_level.txt,sha256=3Hb6PpNkJYXvzDKXuuFJRvzCdsTRh0TuRWz-ScJ6qV0,14
+mini_code_cli-0.0.8.0.dist-info/RECORD,,

mini_code_cli-0.0.7.dist-info/RECORD

@@ -1,11 +0,0 @@
-mini_code_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_code_cli/agent_loop.py,sha256=IC02Hs2oBx4C1apFXmJ2E3ESmJLP8v2Z6_0ApLDdZo4,5877
-mini_code_cli/prompts.py,sha256=1dY5f7pSvfDnjhA-uDmi0Rw66_JFQGfooF699pATO0E,1985
-mini_code_cli/tools.py,sha256=RO51ZJ61NV_R8KqsW9me4-0HPhjgS3DMoKrASLBvYJI,4931
-mini_code_cli/utils.py,sha256=HlmuLH0V4AxZTg0_ZGzlxffqRqs7T3W6FQXaBhioGdk,3647
-mini_code_cli-0.0.7.dist-info/licenses/LICENSE,sha256=WCkMINUFi--UtEg_alEE2FBKPtNKkzi7dGzaxzchifc,1088
-mini_code_cli-0.0.7.dist-info/METADATA,sha256=6_sPZqA8K3sMvMSufEi6__6favkr6O63yBdq17ZC5S0,1943
-mini_code_cli-0.0.7.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-mini_code_cli-0.0.7.dist-info/entry_points.txt,sha256=MwDp5UbXpI7wodSmOSYL8_nKutnBiyp96ZDDtaX7x14,60
-mini_code_cli-0.0.7.dist-info/top_level.txt,sha256=3Hb6PpNkJYXvzDKXuuFJRvzCdsTRh0TuRWz-ScJ6qV0,14
-mini_code_cli-0.0.7.dist-info/RECORD,,