mini-code-cli 0.0.7.1__tar.gz → 0.0.8.1__tar.gz

mini_code_cli-0.0.8.1/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: mini-code-cli
+Version: 0.0.8.1
+Summary: Minimal Coding CLI
+Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
+License: The MIT License (MIT)
+        
+        Copyright © 2026 Nikolai Rozanov
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Project-URL: Homepage, https://github.com/ai-nikolai/mini-code-cli
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# A minimal coding agent cli
+
+> No bloat, no dependencies, no tracking, no telemetry...
+
+Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
+
+## Getting started:
+
+### Installation (from pypi)
+```bash
+pip3 install mini-code-cli
+```
+
+### 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 --help
+```
+```
+Agent loop for interacting with a language model
+
+options:
+  -h, --help            show this help message and exit
+  --url URL             API host
+  --max-tokens MAX_TOKENS
+                        Maximum tokens for LLM response
+  --temperature TEMPERATURE
+                        Temperature for LLM
+  --model MODEL         Model name
+  --api-key API_KEY     API key for authentication. If not set, it tries to find it in env variable: MINI_CODE_API_KEY.
+  --cache-dir CACHE_DIR
+                        The cache dir for the session histories.
+  --system-prompt SYSTEM_PROMPT
+                        Replace system prompt, with a custom system prompt.
+  --auto-mode           Whether to run the agent in `auto-mode'. Or default: `manual-mode'.
+  --agent-md AGENT_MD   If the agent should use an agent-md file... (it will added after system message.)
+  --prompt PROMPT       An initial prompt from the user...
+  --ask-permission      Ask for permission before any tool call.
+  --allowed-dir ALLOWED_DIR
+                        Allowed directory for file operations
+  --enable-shell        Allow shell execution. Default: False
+  ```
+
+
+## (C) Nikolai Rozanov, 2026 - Present

mini_code_cli-0.0.8.1/README.md

@@ -0,0 +1,72 @@
+# A minimal coding agent cli
+
+> No bloat, no dependencies, no tracking, no telemetry...
+
+Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
+
+## Getting started:
+
+### Installation (from pypi)
+```bash
+pip3 install mini-code-cli
+```
+
+### 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 --help
+```
+```
+Agent loop for interacting with a language model
+
+options:
+  -h, --help            show this help message and exit
+  --url URL             API host
+  --max-tokens MAX_TOKENS
+                        Maximum tokens for LLM response
+  --temperature TEMPERATURE
+                        Temperature for LLM
+  --model MODEL         Model name
+  --api-key API_KEY     API key for authentication. If not set, it tries to find it in env variable: MINI_CODE_API_KEY.
+  --cache-dir CACHE_DIR
+                        The cache dir for the session histories.
+  --system-prompt SYSTEM_PROMPT
+                        Replace system prompt, with a custom system prompt.
+  --auto-mode           Whether to run the agent in `auto-mode'. Or default: `manual-mode'.
+  --agent-md AGENT_MD   If the agent should use an agent-md file... (it will added after system message.)
+  --prompt PROMPT       An initial prompt from the user...
+  --ask-permission      Ask for permission before any tool call.
+  --allowed-dir ALLOWED_DIR
+                        Allowed directory for file operations
+  --enable-shell        Allow shell execution. Default: False
+  ```
+
+
+## (C) Nikolai Rozanov, 2026 - Present

{mini_code_cli-0.0.7.1 → mini_code_cli-0.0.8.1}/mini_code_cli/agent_loop.py

@@ -10,13 +10,18 @@ write a similar model.py file but for a LSTM based language model. Make it minim
 
 import os
 import json
+import signal
+
+import time
+import uuid
+
+import argparse
+import sys
 
 from . import prompts
 from . import tools
 from . import utils
 
-import argparse
-import sys
 
 # ANSI escape codes for colors and bold
 BOLD = '\033[1m'
@@ -28,42 +33,69 @@ MAGENTA = '\033[95m'
 CYAN = '\033[96m'
 RESET = '\033[0m'
 
-def save_history(messages):
+def save_history(messages, args, session_name=""):
     # Save messages to history.json
-    with open("history.json", "w") as f:
+    if args.cache_dir:
+        cache_dir = args.cache_dir
+    else:
+        cache_dir = os.path.expanduser("~/.cache/mini_code/sessions/")
+    os.makedirs(cache_dir, exist_ok=True)
+    history_path = os.path.join(cache_dir, f"history_{session_name}.json")
+    with open(history_path, 'w') as f:
         json.dump(messages, f, indent=2)
 
+def generate_unique_id():
+    """Generate a unique ID based on current time and a random component."""
+    timestamp = int(time.time() * 1000000)  # microseconds
+    return f"{timestamp}-{uuid.uuid4().hex[:8]}"
 
 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("--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.")
+    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.")
+
+    # Other settings:
+    parser.add_argument("--cache-dir", type=str, help="The cache dir for the session histories.")
+
+
+    # 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.)")
+    parser.add_argument("--prompt", type=str, help="An initial prompt from the user...")
+
+    # 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, args):
+
+def print_welcome(allowed_dir, server_url, args, unique_id, cache_dir):
     # 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."
+    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 = [
         f"  MiniCodeCLI (v{version})",
+        f"  The session-id is: {unique_id}" ,
+        f"  It will be saved under: `{cache_dir}`",
          "  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."
+        f"  {shell_mode}"
     ]
     max_len = max(len(line) for line in lines)
     margin = 2  # Space on each side inside the box
@@ -78,23 +110,71 @@ def print_welcome(allowed_dir, server_url, args):
     bottom = "╚" + "═" * inner_width + "╝"
     print(bottom)
 
-def print_help(allowed_dir, server_url, args):
-    print_welcome(allowed_dir, server_url, args)
+def print_help(allowed_dir, server_url, args, unique_id, cache_dir):
+    print_welcome(allowed_dir, server_url, args, unique_id, cache_dir)
     
     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."
+    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)
+    # Get session unique ID:
+    unique_id = generate_unique_id()
+    cache_dir = args.cache_dir if args.cache_dir else "~/.cache/mini_code/sessions/"
+
+    # 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}")
+
+    
+    # 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_dict = tools.util_get_tools_dict()
-    llm_tools_dict = tools.util_get_tools()
+    # 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:
@@ -102,16 +182,35 @@ def main():
 
     messages = [{"role": "system", "content": system_prompt}]
 
-    print_welcome(allowed_dir, server_url, args)
+    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, unique_id, cache_dir)
 
+    # Agent Logic Flags
     llm_response_flag = False
     llm_tool_response_flag = False
     llm_repeat_flag = False
     tool_count = 0
     
+    user_input = args.prompt
+
     while True:
-        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.")
+
+        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
@@ -119,23 +218,29 @@ def main():
                 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"]:
+            if not user_input:
+                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, args, unique_id)
+                        break
+                except KeyboardInterrupt:
                     print("\nThank you. Goodbye! Saving history...")
-                    save_history(messages)
+                    save_history(messages, args, unique_id)
                     break
-            except KeyboardInterrupt:
-                print("\nThank you. Goodbye! Saving history...")
-                save_history(messages)
-                break
+            else:
+                print("-"*30)
+                print(f"{BOLD}{CYAN}You (preset): {RESET}{user_input}")
             
             if user_input == "/help":
-                print_help(allowed_dir, server_url, args)
+                print_help(allowed_dir, server_url, args, unique_id, cache_dir)
+                user_input = ""
                 continue
 
             messages.append({"role": "user", "content": user_input})
+            user_input = ""
 
         llm_response_flag = False
         llm_tool_response_flag = False
@@ -146,7 +251,8 @@ 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:
@@ -195,7 +301,7 @@ def main():
                             permission_input = input("Type: 'y' or 'yes'\n")
                         except KeyboardInterrupt:
                             print("\nThank you. Goodbye! Saving history...")
-                            save_history(messages)
+                            save_history(messages, args, unique_id)
                             sys.exit(0)
 
                         if not permission_input in ['y', 'yes']:
@@ -205,7 +311,9 @@ def main():
                                 "content": f"User denied permission for tool {name} and params {params_str}."
                             })
                             continue
-                    result = func(**tool_params)
+
+                    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:
@@ -218,7 +326,12 @@ def main():
                         "content": str(result)
                     })
                 else:
-                    print(f"{BOLD}{RED}Warning:{RESET} Unknown tool: {name}, params {params_str}")
+                    print(f"{BOLD}{RED}Error:{RESET} Unknown tool: {name}, params {params_str}")
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": call_id,
+                        "content": f"Error: Unknown tool: {name}, params {params_str}"
+                    })
         else:
             messages.append({
                     "role": "assistant",
@@ -229,7 +342,7 @@ def main():
         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)
+        save_history(messages, args, unique_id)
 
 if __name__ == "__main__":
     main()

{mini_code_cli-0.0.7.1 → mini_code_cli-0.0.8.1}/mini_code_cli/prompts.py

@@ -6,7 +6,7 @@ def system_prompt(tools_dict=None, allowed_dir=None):
 
     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 assistant with access to the following tools:\n"
+        base_prompt = "You are a helpful AI assistant with access to the following tools (only):\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. "

{mini_code_cli-0.0.7.1 → mini_code_cli-0.0.8.1}/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.8.1/mini_code_cli.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: mini-code-cli
+Version: 0.0.8.1
+Summary: Minimal Coding CLI
+Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
+License: The MIT License (MIT)
+        
+        Copyright © 2026 Nikolai Rozanov
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Project-URL: Homepage, https://github.com/ai-nikolai/mini-code-cli
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# A minimal coding agent cli
+
+> No bloat, no dependencies, no tracking, no telemetry...
+
+Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
+
+## Getting started:
+
+### Installation (from pypi)
+```bash
+pip3 install mini-code-cli
+```
+
+### 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 --help
+```
+```
+Agent loop for interacting with a language model
+
+options:
+  -h, --help            show this help message and exit
+  --url URL             API host
+  --max-tokens MAX_TOKENS
+                        Maximum tokens for LLM response
+  --temperature TEMPERATURE
+                        Temperature for LLM
+  --model MODEL         Model name
+  --api-key API_KEY     API key for authentication. If not set, it tries to find it in env variable: MINI_CODE_API_KEY.
+  --cache-dir CACHE_DIR
+                        The cache dir for the session histories.
+  --system-prompt SYSTEM_PROMPT
+                        Replace system prompt, with a custom system prompt.
+  --auto-mode           Whether to run the agent in `auto-mode'. Or default: `manual-mode'.
+  --agent-md AGENT_MD   If the agent should use an agent-md file... (it will added after system message.)
+  --prompt PROMPT       An initial prompt from the user...
+  --ask-permission      Ask for permission before any tool call.
+  --allowed-dir ALLOWED_DIR
+                        Allowed directory for file operations
+  --enable-shell        Allow shell execution. Default: False
+  ```
+
+
+## (C) Nikolai Rozanov, 2026 - Present

{mini_code_cli-0.0.7.1 → mini_code_cli-0.0.8.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mini-code-cli"
 # version = { file = "mini_code_cli/__init__.py", attr = "__version__" }
-version = "0.0.7.1"
+version = "0.0.8.1"
 description = "Minimal Coding CLI"
 readme = "README.md"
 requires-python = ">=3.10"

mini_code_cli-0.0.7.1/PKG-INFO

@@ -1,45 +0,0 @@
-Metadata-Version: 2.4
-Name: mini-code-cli
-Version: 0.0.7.1
-Summary: Minimal Coding CLI
-Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
-License: The MIT License (MIT)
-        
-        Copyright © 2026 Nikolai Rozanov
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-Project-URL: Homepage, https://github.com/ai-nikolai/mini-code-cli
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# A minimal coding agent cli
-
-> No bloat, no dependencies, no tracking...
-
-Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
-
-## Getting started:
-1. Installation (from pypi)
-```bash
-pip3 install mini-code-cli
-```
-
-2. Run agent: (get LLM running via SGLang or Vllm)
-```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/
-```
-
-3. Get help:
-```bash
-mini-code --help
-```
-
-
-## (C) Nikolai Rozanov, 2026 - Present

mini_code_cli-0.0.7.1/README.md

@@ -1,25 +0,0 @@
-# A minimal coding agent cli
-
-> No bloat, no dependencies, no tracking...
-
-Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
-
-## Getting started:
-1. Installation (from pypi)
-```bash
-pip3 install mini-code-cli
-```
-
-2. Run agent: (get LLM running via SGLang or Vllm)
-```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/
-```
-
-3. Get help:
-```bash
-mini-code --help
-```
-
-
-## (C) Nikolai Rozanov, 2026 - Present

mini_code_cli-0.0.7.1/mini_code_cli.egg-info/PKG-INFO

@@ -1,45 +0,0 @@
-Metadata-Version: 2.4
-Name: mini-code-cli
-Version: 0.0.7.1
-Summary: Minimal Coding CLI
-Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
-License: The MIT License (MIT)
-        
-        Copyright © 2026 Nikolai Rozanov
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-Project-URL: Homepage, https://github.com/ai-nikolai/mini-code-cli
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# A minimal coding agent cli
-
-> No bloat, no dependencies, no tracking...
-
-Purpose: A no bloat, minimal coding cli, to enjoy experimenting and researching...
-
-## Getting started:
-1. Installation (from pypi)
-```bash
-pip3 install mini-code-cli
-```
-
-2. Run agent: (get LLM running via SGLang or Vllm)
-```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/
-```
-
-3. Get help:
-```bash
-mini-code --help
-```
-
-
-## (C) Nikolai Rozanov, 2026 - Present