rmk 0.1.0__py3-none-any.whl

rmk-0.1.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: rmk
+Version: 0.1.0
+Summary: Root Monkey (rmk) is an autonomous AI Agent system.
+Author-email: rootmq <mqvvang@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: anthropic>=0.52.0
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: litellm>=1.72.0
+Requires-Dist: openai>=1.82.0
+Requires-Dist: pydantic>=2.11.5
+Requires-Dist: rich>=14.0.0
+Description-Content-Type: text/markdown
+
+# Root Monkey (🛠️🐒⚙️)
+
+Root Monkey (rmk) is an autonomous AI Agent system.
+
+Key Features:
+- High Agent Autonomy: *Less human intervention, more agent autonomy.*
+- Self-Developing: *The system can develop new capabilities on its own.*
+- Simple Design: *Easy to understand and implement.*
+
+
+## Design Philosophy
+
+- "Simplicity is the ultimate sophistication." - Leonardo da Vinci
+
+
+- "The evolution of the model will gradually reduce the complexity of the design." - Root Monkey
+
+
+## Demo - dev setup
+```bash
+pip install rmk
+export OPENAI_API_KEY="your-api-key"
+export MODEL="gpt-4.1"
+
+rmk -t "Please clone the rmonkey project from https://github.com/rootagent/rmk and set up the development environment as described in the contribution file." --verbos
+```

rmk-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+rmonkey/__init__.py,sha256=8u5leZHRym4_CMor70g48x32wcpY6YT-TBBqRYFNLGk,359
+rmonkey/action/__init__.py,sha256=flNLS2Gt9BzrK6TeAv_-z-bXdc3Cvx9N6IJeGc3yKjQ,62
+rmonkey/action/tool_action.py,sha256=svZNxwgmIUst6JBiKCdEGw_h8Ntm_by9LfgSPpXY52U,655
+rmonkey/agents/__init__.py,sha256=C5lhR67pMPt2Qm4iorHf4r1fMVKBA6tNGzVWrYQORns,203
+rmonkey/agents/_base.py,sha256=0e_Z4uLAeNIZsXTfuRjLQjF1p52kzPlR4oe6dHHy528,4910
+rmonkey/agents/ask_agent.py,sha256=pIjcO29vxDOOnzk-pbQzv6joOiHrLyXlhewd9d4w2dA,259
+rmonkey/agents/root_monkey.py,sha256=D6pEY_RAoB3iUBg8oQ8KQtjugGsA25K2Yhp_hAEMAG8,778
+rmonkey/agents/swe_agent.py,sha256=pDD_QzfhO-haiWRYMdmPkBa8RJBlOwJQ46cYGc0q9PM,603
+rmonkey/entrypoints/cli/main.py,sha256=kGd9z7Dr8auCB6rhawdoweEWQRsSxootxgv4_GIh8C4,4562
+rmonkey/llm/__init__.py,sha256=XvtkQCwiOr20gOasAWYeHQ2Y9dHEN1wpzd_xEselYb0,141
+rmonkey/llm/providers/openai.py,sha256=yeBHpCxS62VtuPZZpLd8mdj_9vUnGzIRyxqL1Ji54dE,5736
+rmonkey/memory/__init__.py,sha256=dYWEw_ZP6ZRlLAzdt8Ikc1xtktJmS3GLK-cB364-c-I,63
+rmonkey/memory/memory.py,sha256=DolRhT2_JCeCi7r4ijdG8-Va33Us4BnAnCqAmMvJazo,1569
+rmonkey/plan/__init__.py,sha256=smH3OGj7ppdR3zb9kh_CRJH0OjkrlMt4V9jYauaXwUQ,74
+rmonkey/plan/planning.py,sha256=0k3GHck72qiybkdM4vWoKwf8Bod09J4pxgP5qpYo-iM,4146
+rmonkey/tools/__init__.py,sha256=H0h-im1wnie9IMl0FJrmSigdu4ZyILfKeXw17jjXhfo,465
+rmonkey/tools/_base.py,sha256=pLWRD6A8_Ebi42zxH9n_PjUpYYkOgA9gKUZnnIMXSrQ,881
+rmonkey/tools/code_interpreter.py,sha256=1FP-Xr-QiU66SvUprHMZdKgXSRQ7MPDkt7EQseud8yc,796
+rmonkey/tools/human.py,sha256=4gkMLQml14NUWvlQvKEVZO_-LMeyMkKLmwnfWEc3Y2M,677
+rmonkey/tools/terminal_bash.py,sha256=tMhI9MVTPRy_GJqFKZMyCyDF_JV4Qubo4OnPVunDzE0,1014
+rmonkey/tools/text_file_editor.py,sha256=sT5LqqLka2TKf6f4ZOa-0elj7o4XMPlwQkolohXtrCw,4836
+rmonkey/tools/think.py,sha256=ye4nyMxJ2S1TcfFuzG2Bfplyus2kcs_RvdZ2MB-60a4,467
+rmonkey/tools/tool_set.py,sha256=je6YOV4v7dPFa2VnYH_pCoPmLl2abQaHxL-pJzcsfy4,646
+rmonkey/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rmonkey/utils/os_info.py,sha256=RSId0xkbwXzwcOIzbE05lOw95dHXnFvRMWd6_Mi1fPs,261
+rmonkey/utils/pretty_console.py,sha256=m0nUZ3IAi47rsckhOIRFKqiMKvipN_Ztqt0AlhKJWnM,444
+rmonkey/utils/schema.py,sha256=l7ftopJcZAXzpBZ9JYiULH7qVheSS3vbuIgBtctvptw,773
+rmonkey/utils/user_rules.py,sha256=D8MkLHyqUFZCBg1PMLW915jun_SKVoo4yzsH0xV1Gzk,439
+rmonkey/utils/util.py,sha256=nup6b8FqTUTQVgn-yhFnkvNkFNBjMeg7wB3wEsa0vVM,336
+rmk-0.1.0.dist-info/METADATA,sha256=7BxaLxt9solcC_HHesVblXhy0kOA7An1PRIzVBbNdcQ,1164
+rmk-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rmk-0.1.0.dist-info/entry_points.txt,sha256=CRR8j38CZ68SvkiYhm7FjCwKRXJrRHHCzNd5HT2LfSI,58
+rmk-0.1.0.dist-info/RECORD,,

rmk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rmk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rmk = rmonkey.entrypoints.cli.main:main

rmonkey/__init__.py

@@ -0,0 +1,17 @@
+from rmonkey.action.tool_action import ToolAction
+from rmonkey.agents import AskAgent, RootMonkey, SWEAgent
+from rmonkey.memory import Memory
+from rmonkey.utils.schema import Message, Role
+
+__version__ = "0.1.0.dev"
+
+__all__ = [
+    "Role",
+    "Message",
+    "AskAgent",
+    "RootMonkey",
+    "SWEAgent",
+    "Memory",
+    "ToolAction",
+    "__version__",
+]

rmonkey/action/__init__.py

@@ -0,0 +1,3 @@
+from .tool_action import ToolAction
+
+__all__ = ["ToolAction"]

rmonkey/action/tool_action.py

@@ -0,0 +1,23 @@
+import json
+
+from rmonkey.tools import Tool
+
+
+class ToolAction:
+    def __init__(self, tools: list[Tool] | None = None):
+        self.tools = tools
+        self.tool_map = {tool.name: tool for tool in tools}
+
+    def execute(self, name: str, arguments: str, **kwargs) -> str:
+        tool = self.tool_map.get(name, None)
+        if not tool:
+            return f"Tool {name} is not available."
+        try:
+            arguments = json.loads(arguments)
+        except json.JSONDecodeError:
+            return f"Invalid arguments for tool {name}."
+
+        try:
+            return tool(**arguments)
+        except Exception as e:
+            return str(e)

rmonkey/agents/__init__.py

@@ -0,0 +1,11 @@
+from ._base import Agent
+from .ask_agent import AskAgent
+from .root_monkey import RootMonkey
+from .swe_agent import SWEAgent
+
+__all__ = [
+    "Agent",
+    "AskAgent",
+    "RootMonkey",
+    "SWEAgent",
+]

rmonkey/agents/_base.py

@@ -0,0 +1,138 @@
+import os
+from contextlib import ExitStack
+from pathlib import Path
+
+from rmonkey.action import ToolAction
+from rmonkey.llm import OpenAIHandler
+from rmonkey.memory import Memory
+from rmonkey.tools import Tool, Toolset
+from rmonkey.utils.pretty_console import PrettyConsole
+from rmonkey.utils.schema import Message, Role
+from rmonkey.utils.util import generate_session_id
+
+
+class Agent:
+    # attributes
+    name: str = "BaseAgent"
+    description: str = "This is a base agent that does nothing."
+
+    # https://lilianweng.github.io/posts/2023-06-23-agent/
+    # agent key components: LLM, Memory, Tools, Planning, Action
+
+    llm_handler: OpenAIHandler = None
+    system: str = None
+    system_rules: str = None
+
+    memory: Memory = None
+    tools: Toolset = None
+    action: ToolAction = None
+    planning: str = None
+
+    # runtime settings
+    session_id: str | None = None
+    max_turns: int = 30
+    run_step: int = 0
+    run_state = None
+
+    def __init__(
+        self,
+        name: str,
+        system: str = None,
+        tools: list[Tool] | None = None,
+        provider: str = "openai",
+        model: str = "gpt-4.1",
+        max_tokens: int = 4096,
+        temperature: float = 0.7,
+        session_id: str | None = None,
+        verbose: bool = False,
+        console: PrettyConsole = None,
+        **kwargs,
+    ):
+        self.name = name
+        if system is not None:
+            self.system = system
+        self.system_rules = kwargs.get("system_rules")
+        self.model = model
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+
+        if tools:
+            self.tools = Toolset(tools=tools)
+            self.action = ToolAction(tools=tools)
+
+        self.init_llm_handler(provider)
+
+        self.session_id = session_id if session_id else generate_session_id()
+        self.memory = Memory(id=self.session_id)
+        if self.system:
+            system_content = self.system
+            if self.system_rules:
+                system_content = f"{system_content}\n\n<system>\n{self.system_rules}\n</system>"
+            self.memory.add_message(role=Role.SYSTEM, content=system_content)
+        self.verbose = verbose
+        self.console = console
+
+    @classmethod
+    def create(cls, **kwargs) -> "Agent":
+        return cls(**kwargs)
+
+    def init_llm_handler(self, provider: str = "openai"):
+        if provider == "openai":
+            self.llm_handler = OpenAIHandler(
+                base_url=os.getenv("BASE_URL", None),
+                api_version=os.getenv("API_VERSION", None),
+                api_key=os.getenv("OPENAI_API_KEY", None),
+                model=os.getenv("OPENAI_MODEL", self.model),
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+            )
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")
+
+    def _llm_with_tool(self, prompt: str) -> Message:
+        """process a prompt and handle tool calls in a loop"""
+
+        self.memory.add_message(role=Role.USER, content=prompt)
+        if self.verbose:
+            self.console.print(prompt, Role.USER)
+        while True:
+            result: Message = self.llm_handler.call(
+                self.memory.get_messages(),
+                self.tools.schema() if self.tools else None,
+            )
+            self.memory.add_message(result)
+            if result.tool_calls:
+                if self.verbose and result.content:
+                    self.console.print(result.content, result.role)
+                for tool_call in result.tool_calls:
+                    if self.verbose:
+                        self.console.print(tool_call, result.role)
+                        input("Press Enter to continue with the tool call...")
+                    name = tool_call.function.name
+                    arguments = tool_call.function.arguments
+                    tool_call_output = self.action.execute(name=name, arguments=arguments)
+                    self.memory.add_message(role=Role.TOOL, content=tool_call_output, tool_call_id=tool_call.id)
+                    if self.verbose:
+                        self.console.print(tool_call_output, Role.TOOL)
+            else:
+                if self.verbose:
+                    self.console.print(result.content, result.role)
+                return result
+
+    def run(self, prompt: str) -> str:
+        agent_result = None
+
+        with ExitStack() as stack:
+            try:
+                step_response = self._llm_with_tool(prompt)
+                agent_result = step_response.content
+            except Exception as e:
+                print(f"Agent Sys Error: {e}")
+        return agent_result
+
+    def save(self, save_dir: str) -> str:
+        if not Path(save_dir).exists():
+            Path(save_dir).mkdir(parents=True)
+        save_file = Path(save_dir) / f"{self.session_id}.jsonl"
+        self.memory.save(save_file)
+        return str(save_file)

rmonkey/agents/ask_agent.py

@@ -0,0 +1,7 @@
+from rmonkey.agents import Agent
+
+
+class AskAgent(Agent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(name="AskAgent", system="You are a powerful AI agent.", **kwargs)
+        self.description = "This agent is used to answer questions."

rmonkey/agents/root_monkey.py

@@ -0,0 +1,22 @@
+from rmonkey.agents import Agent
+from rmonkey.plan import Planning
+from rmonkey.tools import TerminalBash, TextFileEditor, Think
+
+
+class RootMonkey(Agent):
+    def __init__(self, system_rules: str, session_id: str, verbose: bool = False, console=None, *args, **kwargs):
+        super().__init__(
+            name="RootMonkey",
+            system="As an autonomous AI agent, I am known as Root Monkey (rmk).",
+            system_rules=system_rules,
+            tools=[
+                Planning(),
+                TextFileEditor(),
+                TerminalBash(),
+                Think(),
+            ],
+            session_id=session_id,
+            verbose=verbose,
+            console=console,
+        )
+        self.description = "Root Monkey, an autonomous AI Agent system."

rmonkey/agents/swe_agent.py

@@ -0,0 +1,19 @@
+from rmonkey.agents import Agent
+from rmonkey.plan import Planning
+from rmonkey.tools import CodeInterpreter, TerminalBash, TextFileEditor, Think
+
+
+class SWEAgent(Agent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            name="SWEAgent",
+            system="You are an autonomous AI software engineer.",
+            tools=[
+                Planning(),
+                TextFileEditor(),
+                TerminalBash(),
+                CodeInterpreter(),
+                Think(),
+            ],
+        )
+        self.description = "an autonomous AI Software Engineer agent."

rmonkey/entrypoints/cli/main.py

@@ -0,0 +1,134 @@
+# The CLI entrypoint to root monkey (rmk).
+
+import argparse
+import logging
+import os
+import signal
+import sys
+from pathlib import Path
+
+from rmonkey import AskAgent, RootMonkey, SWEAgent, __version__
+from rmonkey.utils import os_info, user_rules
+from rmonkey.utils.pretty_console import PrettyConsole
+from rmonkey.utils.util import generate_session_id
+
+logger = logging.getLogger(__name__)
+
+agent: AskAgent | SWEAgent | RootMonkey = None
+agent_log_dir = Path.cwd() / ".rmk" / "traj"
+
+
+def _register_signal_handlers():
+    def signal_handler(signum, frame):
+        logger.debug(f"Received {signum} signal.")
+        logger.info(f"Saved trajectory to {agent_log_dir} and exiting...")
+        global agent
+        traj_file = agent.save(agent_log_dir)
+        print(f"Saved agent trajectory to {traj_file} and exiting...")
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)  # Handle Ctrl+C
+    signal.signal(signal.SIGTSTP, signal_handler)  # Handle Ctrl+Z
+
+
+def main():
+    _register_signal_handlers()
+    parser = argparse.ArgumentParser(description="RootMonkey CLI.")
+
+    parser.add_argument(
+        "--version",
+        "-v",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show the version number and exit",
+    )
+    parser.add_argument(
+        "--mode",
+        "-m",
+        type=str,
+        default="dev",
+        choices=["ask", "agent", "dev"],
+        required=False,
+        help="RMK mode: ask, agent, or dev. default is 'dev'.",
+    )
+    parser.add_argument(
+        "--task",
+        "-t",
+        type=str,
+        help="user's input task.",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output to observe LLM behavior.",
+    )
+    args = parser.parse_args()
+
+    global agent
+    console = PrettyConsole()
+    session_id = generate_session_id()
+    verbose = args.verbose
+    if args.mode == "ask":
+        agent = AskAgent()
+        while True:
+            try:
+                input_message = input("RMK[ask] > ")
+                if not input_message.strip():
+                    console.print("Input cannot be empty. Please try again.")
+                    continue
+                if input_message.strip().lower() in ["/exit", "/quit"]:
+                    traj_file = agent.save(agent_log_dir)
+                    print(f"Saved ask history to {traj_file} and exiting...")
+                    return
+                result = agent.run(input_message)
+                console.print(f"Agent Result:\n{result}", "assistant")
+            except Exception as e:
+                print(str(e))
+                return
+    elif args.mode == "agent":
+        agent = SWEAgent()
+        input_task = args.task
+        while True:
+            try:
+                if not input_task:
+                    input_task = input("RMK[agent] > ")
+                    if not input_task.strip():
+                        console.print("Input task cannot be empty. Please try again.")
+                        continue
+                result = agent.run(input_task)
+                console.print(f"RMK[agent] > \n{result}")
+                input_message = input("RMK[agent] > ")
+                if input_message.strip().lower() in ["/exit", "/quit"]:
+                    traj_file = agent.save(agent_log_dir)
+                    print(f"Saved agent trajectory to {traj_file} and exiting...")
+                    return
+            except Exception as e:
+                print(str(e))
+                return
+    elif args.mode == "dev":
+        system_ctx = os_info.system()
+        user_rules_ctx = user_rules.load_rmk_rules(os.getcwd())
+        if user_rules_ctx:
+            system_ctx = f"{system_ctx}\n{user_rules_ctx}"
+        agent = RootMonkey(system_rules=system_ctx, session_id=session_id, verbose=verbose, console=console)
+        input_task = args.task
+        try:
+            if not input_task:
+                while True:
+                    input_task = input("RMK[dev] > ")
+                    if not input_task.strip():
+                        console.print("Input task cannot be empty. Please try again.")
+                    else:
+                        break
+            result = agent.run(input_task)
+            console.print(f"RMK[dev] > {result}", "assistant")
+            traj_file = agent.save(agent_log_dir)
+            print(f"Saved dev trajectory to {traj_file} and exiting...")
+        except Exception as e:
+            print(str(e))
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

rmonkey/llm/__init__.py

@@ -0,0 +1,7 @@
+from rmonkey.llm.providers.openai import OpenAIHandler
+from rmonkey.utils.schema import Role
+
+__all__ = [
+    "Role",
+    "OpenAIHandler",
+]

rmonkey/llm/providers/openai.py

@@ -0,0 +1,160 @@
+import logging
+from typing import Any
+
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI
+from openai.types.chat import ChatCompletion, ChatCompletionMessage
+
+from rmonkey.utils.schema import Message, Role
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIHandler:
+    base_url: str = None
+    api_version: str = None
+    api_key: str = None
+    model: str = "gpt-4.1"
+    max_tokens: int = 1024 * 8
+    temperature: float = 0.7
+
+    client: AzureOpenAI | OpenAI = None
+    aclient: AsyncAzureOpenAI | AsyncOpenAI = None
+
+    def __init__(
+        self, base_url: str, api_version: str, api_key: str, model: str, max_tokens: int, temperature: float, **kwargs
+    ):
+        self.base_url = base_url
+        self.api_version = api_version
+        self.api_key = api_key
+        self.model = model
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+
+        if api_version and "azure.com" in base_url:
+            self.aclient = AsyncAzureOpenAI(
+                azure_endpoint=base_url,
+                api_version=api_version,
+                api_key=api_key,
+            )
+            self.client = AzureOpenAI(
+                azure_endpoint=base_url,
+                api_version=api_version,
+                api_key=api_key,
+            )
+        else:
+            self.aclient = AsyncOpenAI(
+                api_key=api_key,
+            )
+            self.client = OpenAI(
+                api_key=api_key,
+            )
+
+    def call(
+        self,
+        messages: list[dict],
+        tools: list[dict[str, Any]] | None = None,
+        model: str | None = None,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        stream: bool = False,
+        top_p: float | None = None,
+    ) -> Message:
+        if stream and tools:
+            logger.warning("Streaming is not supported for tool calls. Disabling streaming.")
+            stream = False
+
+        _config = {
+            "model": model if model else self.model,
+            "messages": messages,
+            "max_tokens": max_tokens if max_tokens else self.max_tokens,
+            "temperature": temperature if temperature else self.temperature,
+            "top_p": top_p if top_p else 0.95,
+        }
+        if tools:
+            _config["tools"] = tools
+
+        if not stream:
+            response: ChatCompletion = self.client.chat.completions.create(**_config)
+            if not response.choices or not response.choices[0].message:
+                raise ValueError(f"Invalid response from LLM {_config['model']}")
+            _message: ChatCompletionMessage = response.choices[0].message
+            response_content = _message.content
+            tool_calls = _message.tool_calls
+            return Message(role=Role.ASSISTANT, content=response_content, tool_calls=tool_calls)
+        else:
+            _config["stream"] = True
+            response = self.client.chat.completions.create(**_config)
+            chunks = []
+
+            for chunk in response:
+                chunk_text = chunk.choices[0].delta.content or ""
+                chunks.append(chunk_text)
+                print(chunk_text, end="", flush=True)
+            response_content = "".join(chunks)
+            return Message(role=Role.ASSISTANT, content=response_content)
+
+    async def acall(
+        self,
+        messages: list[dict],
+        tools: list[dict[str, Any]] | None = None,
+        config: dict[str, Any] | None = None,
+    ) -> Message:
+        stream = config.get("stream", False)
+        if stream and tools:
+            logger.warning("Streaming is not supported for tool calls. Disabling streaming.")
+            stream = False
+
+        _config = {
+            "model": config.get("model", "gpt-4.1"),
+            "messages": messages,
+            "max_tokens": config.get("max_tokens", 1024 * 8),
+            "temperature": config.get("temperature", 0.7),
+            "top_p": config.get("top_p", 0.95),
+        }
+        if tools:
+            _config["tools"] = tools
+
+        if not stream:
+            response: ChatCompletion = await self.aclient.chat.completions.create(**_config)
+            if not response.choices or not response.choices[0].message:
+                raise ValueError(f"Invalid response from LLM {_config['model']}")
+            _message: ChatCompletionMessage = response.choices[0].message
+            response_content = _message.content
+            tool_calls = _message.tool_calls
+            return Message(role=Role.ASSISTANT, content=response_content, tool_calls=tool_calls)
+        else:
+            _config["stream"] = True
+            chunks = []
+            async for chunk in self.aclient.chat.completions.create(**_config):
+                chunk_text = chunk.choices[0].delta.content or ""
+                chunks.append(chunk_text)
+                print(chunk_text, end="", flush=True)
+            response_content = "".join(chunks)
+        return Message(role=Role.ASSISTANT, content=response_content)
+
+
+def mock_openai_call(
+    messages: list[dict],
+    tools: list[dict[str, Any]] | None = None,
+    **kwargs,
+) -> Message:
+    from openai.types.chat import ChatCompletionMessageToolCall
+    from openai.types.chat.chat_completion_message_tool_call import Function
+
+    mock_tool_calls = None
+    if tools:
+        mock_tool_calls = [
+            ChatCompletionMessageToolCall(
+                id="call_xxx",
+                type="function",
+                function=Function(
+                    name="get_weather",
+                    arguments='{"location":"Paris, France"}',
+                ),
+            )
+        ]
+    return Message(
+        role=Role.ASSISTANT,
+        content="This is a mock response.",
+        tool_calls=mock_tool_calls,
+    )

rmonkey/memory/__init__.py

@@ -0,0 +1,3 @@
+from rmonkey.memory.memory import Memory
+
+__all__ = ["Memory"]

rmonkey/memory/memory.py

@@ -0,0 +1,51 @@
+import json
+
+from rmonkey.utils.schema import Message
+
+
+class Memory:
+    id: str = None
+    messages: list[Message] = []
+
+    max_messages: int = 100
+    context_window_tokens: int = 128_000
+    total_tokens: int = 0
+
+    def __init__(self, id: str = None, max_messages: int = 100, context_window_tokens: int = 128_000) -> None:
+        self.id = id
+        self.max_messages = max_messages
+        self.context_window_tokens = context_window_tokens
+        self.messages = []
+        self.total_tokens = 0
+
+    def set_id(self, session_id: str) -> None:
+        self.session_id = session_id
+
+    def add_message(
+        self,
+        message: Message = None,
+        role: str = None,
+        content: str = None,
+        tool_calls: list[dict] | None = None,
+        tool_call_id: str | None = None,
+    ) -> None:
+        if message is not None and isinstance(message, Message):
+            self.messages.append(message)
+        else:
+            m = Message(role=role, content=content, tool_calls=tool_calls, tool_call_id=tool_call_id)
+            self.messages.append(m)
+
+    def clear(self) -> None:
+        self.messages.clear()
+
+    def get_messages(self) -> list[dict]:
+        return [msg.json() for msg in self.messages]
+
+    def truncate(self) -> None:
+        if len(self.messages) > self.max_messages:
+            self.messages = self.messages[-self.max_messages :]
+
+    def save(self, save_path: str):
+        with open(save_path, "w") as f:
+            for msg in self.messages:
+                f.write(json.dumps(msg.json(exclude_none=True)) + "\n")

rmonkey/plan/__init__.py

@@ -0,0 +1,5 @@
+from rmonkey.plan.planning import Planning
+
+__all__ = [
+    "Planning",
+]

rmonkey/plan/planning.py

@@ -0,0 +1,108 @@
+import re
+from pathlib import Path
+
+from rmonkey.tools import Tool
+
+_description = """
+This planning tool helps you view, create, manage, and break down highly complex tasks into manageable sub-tasks, making intricate problem-solving more efficient.
+**Only employ this tool when you encounter a task that is exceptionally difficult and complex**
+""".strip()  # noqa: E501
+
+
+def parse_diff_blocks(diff: str) -> list:
+    pattern = r"<<<<<<< SEARCH\n(.*?)\n=======\n(.*?)\n>>>>>>> REPLACE"
+    matches = re.findall(pattern, diff, re.DOTALL)
+    blocks = []
+    for s, r in matches:
+        blocks.append((s, r))
+    return blocks
+
+
+class Planning(Tool):
+    name: str = "planning"
+    description: str = _description
+
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "operation": {
+                "description": "The operation to perform.",
+                "enum": [
+                    "view",
+                    "create",
+                    "update",
+                    "decompose",
+                ],
+                "type": "string",
+            },
+            "path": {
+                "description": "The absolute file path for storing the plan.",
+                "type": "string",
+            },
+            "content": {
+                "description": "The Markdown-formatted overall plan to achieve the goal. Required for `create`.",
+                "type": "string",
+            },
+            "diff_content": {
+                "description": (
+                    "To update the current plan in the `path`, "
+                    "provide the diff content as SEARCH/REPLACE blocks. Required for `update`."
+                ),
+                "type": "string",
+            },
+            "subtasks": {
+                "description": "The list of tasks or steps to be performed. "
+                "Subtasks will be appended to the plan. Required for `decompose`.",
+                "type": "array",
+                "items": {"type": "string"},
+            },
+        },
+        "required": ["command", "path"],
+        "additionalProperties": False,
+    }
+
+    def execute(self, **kwargs) -> str:
+        # valid parameters
+        # operation: str, path: str, content: str = None, diff_content: str = None, subtasks: str = None
+        operation = kwargs.get("operation")
+        path = kwargs.get("path")
+        content = kwargs.get("content")
+        diff_content = kwargs.get("diff_content")
+        subtasks = kwargs.get("subtasks")
+
+        if not operation:
+            return f"{self.name}: `operation` is required."
+        if not path:
+            return f"{self.name}: `path` is required."
+        _path = Path(path)
+        if not _path.exists():
+            return f"{self.name}: File not found: {path}"
+
+        if operation == "view":
+            plan_content = Path(path).read_text()
+            return plan_content
+        elif operation == "create":
+            if content is None:
+                return f"{self.name}: `content` is need for the `create`."
+            Path(path).write_text(content)
+            return "created plan."
+        elif operation == "update":
+            if diff_content is None:
+                return f"{self.name}: `diff_content` is need for the `update`."
+            try:
+                file_content = _path.read_text(encoding="utf-8")
+                blocks = parse_diff_blocks(diff_content)
+                for old_str, new_str in blocks:
+                    file_content = file_content.replace(old_str, new_str)
+                _path.write_text(file_content)
+                return "updated plan."
+            except Exception as e:
+                return f"{self.name}: Error updating plan: {e}"
+        elif operation == "decompose":
+            if subtasks is None:
+                return f"{self.name}: `subtasks` is need for the `decompose`."
+            subtasks_str = "\n".join([f"[ ] Task-{i}\n{s}" for i, s in enumerate(subtasks, start=1)])
+            with open(path, "a") as f:
+                f.write("\n" + subtasks_str)
+            return "subtasks is added to the plan."
+        return f"{self.name}: {operation} is unsupported."

rmonkey/tools/__init__.py

@@ -0,0 +1,17 @@
+from rmonkey.tools._base import Tool
+from rmonkey.tools.code_interpreter import CodeInterpreter
+from rmonkey.tools.human import AskHuman
+from rmonkey.tools.terminal_bash import TerminalBash
+from rmonkey.tools.text_file_editor import TextFileEditor
+from rmonkey.tools.think import Think
+from rmonkey.tools.tool_set import Toolset
+
+__all__ = [
+    "Tool",
+    "CodeInterpreter",
+    "AskHuman",
+    "TerminalBash",
+    "Toolset",
+    "Think",
+    "TextFileEditor",
+]

rmonkey/tools/_base.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class Tool(BaseModel):
+    name: str
+    description: str
+    parameters: dict[str, Any] | None = None
+
+    def __call__(self, **kwargs) -> Any:
+        return self.execute(**kwargs)
+
+    def execute(self, **kwargs) -> str:
+        """Execute the tool with provided parameters."""
+        raise NotImplementedError("Tool subclasses must implement execute method")
+
+    async def aexecute(self, **kwargs) -> str:
+        """Execute the tool with provided parameters."""
+        raise NotImplementedError("Tool subclasses must implement execute method")
+
+    def schema(self) -> dict[str, Any]:
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }

rmonkey/tools/code_interpreter.py

@@ -0,0 +1,25 @@
+from rmonkey.tools._base import Tool
+
+
+class CodeInterpreter(Tool):
+    name: str = "code_interpreter"
+    description: str = "Executes a Python code snippet and returns the print statement output."
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "code": {
+                "type": "string",
+                "description": "The Python script to execute.",
+            },
+        },
+        "required": ["code"],
+    }
+
+    def execute(self, code: str, language: str = "python") -> str:
+        assert language == "python", "Only Python code is supported."
+        try:
+            local_scope = {}
+            exec(code, {}, local_scope)
+            return str(local_scope)
+        except Exception as e:
+            return f"Error executing code: {str(e)}"

rmonkey/tools/human.py

@@ -0,0 +1,23 @@
+from ._base import Tool
+
+
+class AskHuman(Tool):
+    name: str = "ask_human"
+    description: str = "Ask human for help and get a response from human."
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "question": {
+                "type": "string",
+                "description": "The question to ask the human.",
+            }
+        },
+        "required": ["question"],
+    }
+
+    def execute(self, **kwargs) -> str:
+        question = kwargs.get("question", "")
+        human_input = input(f"rMonkey: {question}\nYou: ").strip()
+        if not human_input:
+            return "No response provided by human."
+        return human_input

rmonkey/tools/terminal_bash.py

@@ -0,0 +1,31 @@
+import subprocess
+
+from ._base import Tool
+
+
+class TerminalBash(Tool):
+    name: str = "bash"
+    description: str = "Execute a command in the terminal and return the output."
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "Command to execute in the bash shell.",
+            },
+        },
+        "required": ["command"],
+    }
+
+    def execute(self, **kwargs) -> str:
+        command = kwargs.get("command", "")
+        if not command:
+            return "No command provided."
+
+        try:
+            result = subprocess.run(command, shell=True, check=True, text=True, capture_output=True)
+            return result.stdout.strip() or "Command executed successfully with no output."
+        except subprocess.CalledProcessError as e:
+            return f"Error executing command: {e.stderr.strip()}"
+        except Exception as e:
+            return f"An unexpected error occurred: {str(e)}"

rmonkey/tools/text_file_editor.py

@@ -0,0 +1,130 @@
+import re
+from pathlib import Path
+
+from ._base import Tool
+
+_description = """
+Text file tool for viewing, creating and editing.
+
+* view will return the content of a file, optionally within a specified line range. Each line is prefixed with its line number to help with navigation.
+* create will create a new file with the specified content.
+* edit will apply diff edits to an existing file.
+
+Note: The diff format is a series of SEARCH/REPLACE blocks, every block must use this format:
+1. The start of search block: <<<<<<< SEARCH
+2. A contiguous chunk of lines to search for in the existing file
+3. The dividing line: =======
+4. The lines to replace into the source file
+5. The end of replace block: >>>>>>> REPLACE
+""".strip()  # noqa: E501
+
+
+def parse_diff_blocks(diff: str) -> list:
+    pattern = r"<<<<<<< SEARCH\n(.*?)\n=======\n(.*?)\n>>>>>>> REPLACE"
+    matches = re.findall(pattern, diff, re.DOTALL)
+    blocks = []
+    for s, r in matches:
+        blocks.append((s, r))
+    return blocks
+
+
+class TextFileEditor(Tool):
+    name: str = "text_file_editor"
+    description: str = _description
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "operation": {
+                "description": "File operation to perform.",
+                "type": "string",
+                "enum": ["view", "create", "edit"],
+            },
+            "path": {
+                "description": "Absolute file path.",
+                "type": "string",
+            },
+            "content": {
+                "description": "Plain text content. Required for `create`.",
+                "type": "string",
+            },
+            "diff": {
+                "description": "Diff content (a series of SEARCH/REPLACE blocks). Required for `edit`.",
+                "type": "string",
+            },
+            "view_range": {
+                # `sed -n 'start_line,end_linep' file.txt`
+                "description": "Line range to view (start and end line numbers). Optional for `view`.",
+                "type": "array",
+                "items": {"type": "integer"},
+            },
+        },
+        "required": ["operation", "path"],
+    }
+
+    def execute(self, **kwargs) -> str:
+        operation = kwargs.get("operation")
+        path = kwargs.get("path")
+
+        if operation == "view":
+            view_range = kwargs.get("view_range")
+            return self.view(path, view_range)
+        elif operation == "create":
+            content = kwargs.get("content")
+            return self.create(path, content)
+        elif operation == "edit":
+            diff = kwargs.get("diff")
+            return self.edit(path, diff)
+        else:
+            return f"{self.name}: {operation} is unsupported."
+
+    def view(self, path: str, view_range: list[int] = None) -> str:
+        _path = Path(path)
+        if not _path.exists():
+            return f"{self.name}: File not found: {path}"
+        if view_range and (len(view_range) != 2 or not all(isinstance(i, int) for i in view_range)):
+            return f"{self.name}: Invalid `view_range`: {view_range}."
+        try:
+            file_content = _path.read_text(encoding="utf-8")
+            _lines = file_content.splitlines()
+            if not _lines:
+                return ""
+            max_line_num = len(_lines)
+            width = len(str(max_line_num))
+
+            lines = [f"{i:>{width}} {line}" for i, line in enumerate(_lines, start=1)]
+            if not view_range:
+                return "\n".join(lines)
+            else:
+                start, end = view_range
+                start = int(start)
+                end = int(end)
+                if start < 1 or start > end:
+                    return f"{self.name}: Invalid `view_range`: {view_range}."
+                return "\n".join(lines[start - 1 : end])
+        except Exception as e:
+            return f"{self.name}: Error reading file: {e}"
+
+    def create(self, path: str, content: str) -> str:
+        _path = Path(path)
+        if _path.exists():
+            return f"{self.name}: File already exists: {path}"
+        try:
+            _path.write_text(content, encoding="utf-8")
+            return f"created: {path}"
+        except Exception as e:
+            return f"{self.name}: Error creating file: {e}"
+
+    def edit(self, path: str, diff: str) -> str:
+        _path = Path(path)
+        if not _path.exists():
+            return f"{self.name}: File not found: {path}"
+        try:
+            file_content = _path.read_text(encoding="utf-8")
+            blocks = parse_diff_blocks(diff)
+            for old_str, new_str in blocks:
+                file_content = file_content.replace(old_str, new_str)
+
+            _path.write_text(file_content)
+            return "edited the file."
+        except Exception as e:
+            return f"{self.name}: Error editing file: {e}"

rmonkey/tools/think.py

@@ -0,0 +1,19 @@
+from ._base import Tool
+
+
+class Think(Tool):
+    name: str = "think"
+    description: str = "Used for self-think about something."
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "thought": {
+                "type": "string",
+                "description": "Thinking and summary.",
+            }
+        },
+        "required": ["thought"],
+    }
+
+    def execute(self, thought: str) -> str:
+        return "Thinking completed."

rmonkey/tools/tool_set.py

@@ -0,0 +1,24 @@
+from rmonkey.tools._base import Tool
+
+
+class Toolset:
+    def __init__(self, tools: list[Tool] | None = None):
+        self.tools = tools if tools is not None else []
+
+    def add_tool(self, tool: Tool) -> None:
+        self.tools.append(tool)
+
+    def get_tool(self, name: str) -> Tool | None:
+        for tool in self.tools:
+            if tool.name == name:
+                return tool
+        return None
+
+    def schema(self) -> list[dict]:
+        return [tool.schema() for tool in self.tools]
+
+    def save(self, filepath: str):
+        import json
+
+        with open(filepath, "w") as f:
+            json.dump(self.schema(), f, indent=2)

rmonkey/utils/os_info.py

@@ -0,0 +1,10 @@
+import platform
+
+
+def system(xml=True) -> str:
+    name = f"system/OS name: {platform.system()}".strip()
+    arch = f"arch: {platform.machine()}".strip()
+    info = f"{name}\n{arch}"
+    if xml:
+        return f"<platform>\n{info}\n</platform>"
+    return info

rmonkey/utils/pretty_console.py

@@ -0,0 +1,19 @@
+from rich.console import Console
+from rich.style import Style
+
+roles_color = {
+    "error": "#e32636",
+    "user": "#00ffff",
+    "system": "#bd33a4",
+    "assistant": "#ead9c4",
+    "tool": "#318ce7",
+    "hint": "#fdee00",
+}
+
+
+class PrettyConsole:
+    console = Console()
+
+    def print(self, content: str, key: str = "hint"):
+        color = roles_color.get(key)
+        self.console.print(f"[{key}]: {content}", style=Style(bgcolor=color))

rmonkey/utils/schema.py

@@ -0,0 +1,28 @@
+from enum import Enum
+
+from openai.types.chat import ChatCompletionMessageToolCall
+from pydantic import BaseModel, Field
+
+
+class Role(str, Enum):
+    """LLM API message roles"""
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+    TOOL = "tool"
+
+    def __repr__(self) -> str:
+        return str.__repr__(self.value)
+
+
+class Message(BaseModel):
+    id: str | None = None
+    role: Role = Field(default=Role.USER)
+    content: str | None = Field(default=None)
+    tool_calls: list[ChatCompletionMessageToolCall] | None = Field(default=None)
+    tool_call_id: str | None = Field(default=None)
+
+    def json(self, **kwargs):  # type: ignore
+        exclude_none = kwargs.pop("exclude_none", False)
+        return self.model_dump(exclude_none=exclude_none)

rmonkey/utils/user_rules.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+
+def load_rmk_rules(dir: str, file: str = "system.md", xml=True) -> str | None:
+    """
+    Load the rules from the .rmk/rules directory.
+    """
+    rules_file = Path(dir) / ".rmk" / "rules" / file
+    if not rules_file.exists():
+        return None
+    rules_content = Path(rules_file).read_text().strip()
+    if not rules_content:
+        return None
+    return f"<user_rules>\n{rules_content}\n</user_rules>"

rmonkey/utils/util.py

@@ -0,0 +1,11 @@
+import datetime
+import uuid
+
+
+def generate_session_id():
+    current_datetime = datetime.datetime.now()
+    date_string = current_datetime.strftime("%Y%m%d%H%M%S")
+    # Generate a random UUID and convert to hex string
+    unique_identifier = uuid.uuid4().hex
+    session_id = f"{date_string}-{unique_identifier}"
+    return session_id