mini-code-cli 0.0.6__py3-none-any.whl → 0.0.7.1__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,3 +1,13 @@
+"""
+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
 
@@ -23,17 +33,59 @@ def save_history(messages):
     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("--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, default=2048, help="Maximum tokens for LLM response")
+    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("--step_by_step", action="store_true", help="Whether to run the agent step by step. Default is to run in 'Permission' mode.")
+    parser.add_argument("--ask_permission", action="store_true", help="Ask for permission before any tool call.")
+
     args = parser.parse_args()
     return args
 
+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 args.step_by_step else "Agent is in auto-mode."
+
+    lines = [
+        f"  MiniCodeCLI (v{version})",
+         "  Type 'quit' or 'exit' to exit the loop.",
+        f"  Allowed dir: {allowed_dir}",
+        f"  Server URL: {server_url}",
+        f"  {permission_mode}",
+        f"  {agent_mode}",
+         "  Shell disabled."
+    ]
+    max_len = max(len(line) for line in lines)
+    margin = 2  # Space on each side inside the box
+    inner_width = max_len + 2 * margin
+    # Build the box
+    top_bottom = "╔" + "═" * inner_width + "╗"
+    print(top_bottom)
+    for line in lines:
+        # Pad the line to inner_width characters
+        padded = line.ljust(inner_width)
+        print(f"║{padded}║")
+    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 args.step_by_step 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 main():
     args = parse_args()
 
@@ -43,34 +95,50 @@ def main():
     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)
+    if args.system_prompt:
+        system_prompt = args.system_prompt
+    else:
+        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║    
-    ╚═══════════════════════════════════════════════════════════════════╝
-    """)
+    print_welcome(allowed_dir, server_url, args)
 
+    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 not args.step_by_step: #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.")
+            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, 
@@ -82,54 +150,83 @@ def main():
         )
 
         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.")
-            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"]:
+
+            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", "{}")
+                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 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}")
+                        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"]
+                    # 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
+                    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}, 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/prompts.py

@@ -3,22 +3,30 @@ 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."
+        base_prompt = "You are a helpful AI assistant with access to the following tools:\n"
+        end_prompt = (
+        "Choose the most appropriate tool for the task at hand. "
+        "If a tool fails or you hit a limit, analyze the error and try a different approach. "
+        "Be concise and efficient in your tool usage."
+        )
     else:
         tool_descriptions = ""
-        base_prompt = "You are a helpful AI coding assistant without any tools."
+        base_prompt = "You are a helpful AI assistant without any tools."
         end_prompt = ""
+
+        
+    allowed_dir_prompt = ""
+    if allowed_dir:
+        allowed_dir_prompt = f"\nThe path you are allowed to operate in is called: {allowed_dir}"
+    
     
     prompt = f"""
 {base_prompt}
 {tool_descriptions}{end_prompt}{allowed_dir_prompt}
-Keep responses concise and focused.
+Important: Only follow the user instruction. Do not create additional .md files (unless asked to do so). Do not create unit tests (unless asked to do so), etc.
 """
     return prompt.strip()
 

mini_code_cli/tools.py

@@ -31,7 +31,7 @@ def grep(pattern, filepath):
     except Exception as e:
         return f"Error: {e}"
 
-def glob(pattern):
+def glob(pattern="./"):
     """Return list of file paths matching the given glob pattern. Param: pattern"""
     try:
         return glob_module.glob(pattern)

mini_code_cli/utils.py

@@ -19,9 +19,9 @@ def call_openai_server(messages, max_tokens=2048, temperature=0.0, top_p=0.95, m
     payload = {
         "model": model,
         "messages": messages,
-        "max_tokens": max_tokens,
         "temperature": temperature,
-        "top_p": top_p
+        # "max_tokens": max_tokens,
+        # "top_p": top_p
     }
 
     if tools:

{mini_code_cli-0.0.6.dist-info → mini_code_cli-0.0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.0.6
+Version: 0.0.7.1
 Summary: Minimal Coding CLI
 Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
 License: The MIT License (MIT)
@@ -20,7 +20,9 @@ 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...
+
+Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
 
 ## Getting started:
 1. Installation (from pypi)
@@ -34,5 +36,10 @@ mini-code #run the agent loop
 mini-code --url "https://api.deepseek.com" --model "deepseek-v4-flash" --api-key "sk-dummy" --allowed-dir ./experiments/
 ```
 
+3. Get help:
+```bash
+mini-code --help
+```
+
 
 ## (C) Nikolai Rozanov, 2026 - Present

mini_code_cli-0.0.7.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+mini_code_cli/__init__.py,sha256=iNgHmKSHOuH99obGjnUMoS2JP4Gw4AOrIfu68EYaZQM,77
+mini_code_cli/agent_loop.py,sha256=yr5XCXkEWfGJsRrA-i1v_IcMQXjkUcCo3AGVYA2RLVY,9317
+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.1.dist-info/licenses/LICENSE,sha256=WCkMINUFi--UtEg_alEE2FBKPtNKkzi7dGzaxzchifc,1088
+mini_code_cli-0.0.7.1.dist-info/METADATA,sha256=9X0f_OMDbx-yGKKzhIa1Ywzsxy35IqMevuU14j-HEqc,2028
+mini_code_cli-0.0.7.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mini_code_cli-0.0.7.1.dist-info/entry_points.txt,sha256=MwDp5UbXpI7wodSmOSYL8_nKutnBiyp96ZDDtaX7x14,60
+mini_code_cli-0.0.7.1.dist-info/top_level.txt,sha256=3Hb6PpNkJYXvzDKXuuFJRvzCdsTRh0TuRWz-ScJ6qV0,14
+mini_code_cli-0.0.7.1.dist-info/RECORD,,

mini_code_cli-0.0.6.dist-info/RECORD

@@ -1,11 +0,0 @@
-mini_code_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_code_cli/agent_loop.py,sha256=qrrPAdVZY02xAXNYZGb5s_JhdKPgQdXmunC0Is6nidY,5704
-mini_code_cli/prompts.py,sha256=A8nLnYuCWFuge-H5g7hYdRwXJPnRCg4uH__yYq4PzIU,1737
-mini_code_cli/tools.py,sha256=i46l8IvsrXJgqt7r8rKAMTGKNGAGffxKTFlwmAuWoD0,4926
-mini_code_cli/utils.py,sha256=qQk0RurNeWYoyRj-QmQ81Pq1pytJO87SUzm-XzDz9s4,3643
-mini_code_cli-0.0.6.dist-info/licenses/LICENSE,sha256=WCkMINUFi--UtEg_alEE2FBKPtNKkzi7dGzaxzchifc,1088
-mini_code_cli-0.0.6.dist-info/METADATA,sha256=43JAsEkm4zknm4jKtMDyjbTLTIG8d3XPGCSb2KUWRy8,1943
-mini_code_cli-0.0.6.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-mini_code_cli-0.0.6.dist-info/entry_points.txt,sha256=MwDp5UbXpI7wodSmOSYL8_nKutnBiyp96ZDDtaX7x14,60
-mini_code_cli-0.0.6.dist-info/top_level.txt,sha256=3Hb6PpNkJYXvzDKXuuFJRvzCdsTRh0TuRWz-ScJ6qV0,14
-mini_code_cli-0.0.6.dist-info/RECORD,,