makefile-agent 0.3.0__py3-none-any.whl

make_agent/agent.py

@@ -0,0 +1,190 @@
+"""Interactive REPL agent loop for the make-agent."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Any, NamedTuple
+
+import any_llm
+
+from make_agent.app_dirs import default_agents_dir
+from make_agent.builtin_tools import BUILTIN_SCHEMAS, get_builtin_tools, get_memory_schemas
+from make_agent.memory import Memory
+from make_agent.parser import parse_file, validate_or_raise
+from make_agent.tools import build_tools, format_tool_result, run_tool
+
+_DEFAULT_MODEL = "anthropic/claude-haiku-4-5-20251001"
+_DEFAULT_MAX_RETRIES = 5
+_DEFAULT_TOOL_TIMEOUT = 600  # seconds
+_DEFAULT_MAX_TOOL_OUTPUT = 20000  # characters; 0 = unlimited
+_DEFAULT_MAX_TOKENS = 4096
+
+logger = logging.getLogger(__name__)
+
+
+class AgentConfig(NamedTuple):
+    makefile_path: Path
+    model: str = _DEFAULT_MODEL
+    max_retries: int = _DEFAULT_MAX_RETRIES
+    tool_timeout: int = _DEFAULT_TOOL_TIMEOUT
+    max_tool_output: int = _DEFAULT_MAX_TOOL_OUTPUT
+    max_tokens: int = _DEFAULT_MAX_TOKENS
+    agents_dir: str | None = None
+    debug: bool = False
+    memory: Memory | None = None
+    disabled_builtin_tools: frozenset[str] = frozenset()
+    agent_model: str | None = None  # model used by run_agent; falls back to model
+
+
+def _parse_retry_after(e: any_llm.RateLimitError) -> float | None:
+    """Return the wait time in seconds from a RateLimitError's response headers.
+
+    Checks ``retry-after-ms`` (milliseconds) then ``retry-after`` (seconds).
+    Returns ``None`` when neither header is present.
+    """
+    try:
+        orig = e.original_exception
+        headers = orig.response.headers if orig is not None and hasattr(orig, "response") and orig.response is not None else {}
+    except Exception:
+        return None
+    if ms := headers.get("retry-after-ms"):
+        return float(ms) / 1000
+    if sec := headers.get("retry-after"):
+        return float(sec)
+    return None
+
+
+def _completion_with_retry(
+    model: str,
+    messages: list[dict],
+    tool_kwargs: dict[str, Any],
+    max_retries: int,
+    max_tokens: int = _DEFAULT_MAX_TOKENS,
+) -> Any:
+    """Call ``any_llm.completion``, retrying on rate limit up to *max_retries* times.
+
+    On each ``RateLimitError`` the wait time is read from the ``Retry-After``
+    response header when present, otherwise exponential backoff is used
+    (``2^attempt`` seconds, capped at 60 s).  A message is printed before
+    each retry so the user can see what is happening.
+    """
+    for attempt in range(max_retries + 1):
+        try:
+            return any_llm.completion(model=model, messages=messages, max_tokens=max_tokens, **tool_kwargs)
+        except any_llm.RateLimitError as e:
+            if attempt == max_retries:
+                raise
+            wait = _parse_retry_after(e) or min(2**attempt, 60)
+            print(
+                f"Rate limited, retrying in {wait:.0f}s" f" (attempt {attempt + 1}/{max_retries})...",
+                flush=True,
+            )
+            time.sleep(wait)
+
+
+class Agent:
+    """LLM agent that maintains conversation history and dispatches tool calls.
+
+    Call the instance with a user message to get the assistant's reply::
+
+        agent = Agent(Path("Makefile"), model="anthropic/claude-haiku-4-5-20251001")
+        reply = agent("List the files in the current directory.")
+    """
+
+    def __init__(self, config: AgentConfig) -> None:
+        mf = parse_file(config.makefile_path)
+        validate_or_raise(mf)
+        self._model = config.model
+        self._makefile_path = config.makefile_path
+        self._max_retries = config.max_retries
+        self._max_tokens = config.max_tokens
+        self._tool_timeout = config.tool_timeout
+        self._max_tool_output = config.max_tool_output
+        self._memory = config.memory
+        agents_dir = config.agents_dir if config.agents_dir is not None else default_agents_dir()
+        self._builtins = get_builtin_tools(agents_dir, config.agent_model or config.model, config.debug, config.memory, config.disabled_builtin_tools, config.tool_timeout)
+        makefile_tools = build_tools(mf)
+        memory_schemas = get_memory_schemas() if config.memory is not None else []
+        active_builtin_schemas = [s for s in BUILTIN_SCHEMAS if s["function"]["name"] not in config.disabled_builtin_tools]
+        active_memory_schemas = [s for s in memory_schemas if s["function"]["name"] not in config.disabled_builtin_tools]
+        self._tools = active_builtin_schemas + active_memory_schemas + makefile_tools
+        self._tool_kwargs: dict = {"tools": self._tools, "tool_choice": "auto"} if self._tools else {}
+        self._messages: list[dict] = []
+        if mf.system_prompt:
+            self._messages.append({"role": "system", "content": mf.system_prompt})
+            logger.debug("[system]\n%s", mf.system_prompt)
+
+    @property
+    def tool_names(self) -> list[str]:
+        return [t["function"]["name"] for t in self._tools]
+
+    def __call__(self, user_input: str) -> str:
+        """Send *user_input* to the LLM and return the assistant's reply.
+
+        Dispatches tool calls in a loop until the model returns a plain
+        text response.
+        """
+        self._messages.append({"role": "user", "content": user_input})
+        logger.debug("[user]\n%s", user_input)
+        if self._memory is not None:
+            self._memory.store("user", user_input)
+
+        while True:
+            response = _completion_with_retry(
+                self._model,
+                self._messages,
+                self._tool_kwargs,
+                self._max_retries,
+                self._max_tokens,
+            )
+            msg = response.choices[0].message
+
+            if msg.tool_calls:
+                self._messages.append(msg.model_dump(exclude_none=True))
+
+                for tc in msg.tool_calls:
+                    target = tc.function.name
+                    try:
+                        arguments = json.loads(tc.function.arguments)
+                    except json.JSONDecodeError as e:
+                        output = format_tool_result("", f"malformed JSON arguments: {e}", None)
+                        logger.debug("[tool_result] %s -> %s", target, output)
+                        self._messages.append({"role": "tool", "tool_call_id": tc.id, "content": output})
+                        continue
+
+                    logger.debug("[tool_call] %s args=%s", target, arguments)
+                    try:
+                        if target in self._builtins:
+                            raw = self._builtins[target](**arguments)
+                            output = format_tool_result(str(raw), "", 0, self._max_tool_output)
+                        else:
+                            output = run_tool(
+                                target,
+                                arguments,
+                                self._makefile_path,
+                                self._tool_timeout,
+                                self._max_tool_output,
+                            )
+                    except TypeError as e:
+                        output = format_tool_result("", f"argument type error: {e}", None)
+                    except Exception as e:
+                        output = format_tool_result("", f"unexpected error: {e}", None)
+                    logger.debug("[tool_result] %s -> %s", target, output)
+
+                    self._messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tc.id,
+                            "content": output,
+                        }
+                    )
+            else:
+                content = msg.content or ""
+                self._messages.append({"role": "assistant", "content": content})
+                logger.debug("[assistant]\n%s", content)
+                if self._memory is not None:
+                    self._memory.store("agent", content)
+                return content

make_agent/agent_shell.py

@@ -0,0 +1,93 @@
+import cmd
+from pathlib import Path
+from typing import Optional
+
+from make_agent.agent import _DEFAULT_MAX_RETRIES, _DEFAULT_MAX_TOKENS, _DEFAULT_MAX_TOOL_OUTPUT, _DEFAULT_MODEL, _DEFAULT_TOOL_TIMEOUT, Agent, AgentConfig
+from make_agent.memory import Memory
+
+
+class MakeAgentShell(cmd.Cmd):
+    """Interactive shell that delegates all LLM interaction to an :class:`Agent`."""
+
+    prompt = "make-agent> "
+    intro = ""
+
+    def __init__(self, agent: Agent) -> None:
+        super().__init__()
+        self._agent = agent
+
+    def default(self, line: str) -> None:
+        """Send *line* to the agent and print the reply."""
+        try:
+            print(self._agent(line))
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def emptyline(self) -> None:
+        """Do nothing on an empty line (overrides cmd.Cmd's repeat-last-command)."""
+
+    def do_EOF(self, line: str) -> bool:
+        """Exit on Ctrl-D."""
+        print()
+        return True
+
+    def do_exit(self, line: str) -> bool:
+        """Exit the shell."""
+        return True
+
+    def do_quit(self, line: str) -> bool:
+        """Exit the shell."""
+        return True
+
+
+def run(
+    makefile_path: Path,
+    model: str = _DEFAULT_MODEL,
+    prompt: Optional[str] = None,
+    debug: bool = False,
+    max_retries: int = _DEFAULT_MAX_RETRIES,
+    tool_timeout: int = _DEFAULT_TOOL_TIMEOUT,
+    max_tool_output: int = _DEFAULT_MAX_TOOL_OUTPUT,
+    max_tokens: int = _DEFAULT_MAX_TOKENS,
+    agents_dir: str | None = None,
+    memory: Memory | None = None,
+    disabled_builtin_tools: frozenset[str] = frozenset(),
+    agent_model: str | None = None,
+) -> None:
+    """Start the interactive shell.
+
+    Reads the system prompt and tool definitions from *makefile_path*, then
+    enters a :class:`MakeAgentShell` loop.  Press Ctrl-D, Ctrl-C, or type
+    ``exit`` / ``quit`` to leave.
+
+    When *debug* is ``True`` all messages are logged to
+    ``~/.make-agent/<project>/logs/make-agent.log``.
+    """
+
+    agent_config = AgentConfig(
+        makefile_path=makefile_path,
+        model=model,
+        max_retries=max_retries,
+        tool_timeout=tool_timeout,
+        max_tool_output=max_tool_output,
+        max_tokens=max_tokens,
+        agents_dir=agents_dir,
+        debug=debug,
+        memory=memory,
+        disabled_builtin_tools=disabled_builtin_tools,
+        agent_model=agent_model,
+    )
+    agent = Agent(agent_config)
+    print(f"Loaded {makefile_path}  |  tools: {agent.tool_names}")
+
+    if prompt:
+        print("Sending initial prompt...\n")
+        print(agent(prompt))
+        return
+
+    print("Type your message. Press Ctrl-D or Ctrl-C to exit.\n")
+    shell = MakeAgentShell(agent)
+    try:
+        shell.cmdloop()
+    except KeyboardInterrupt:
+        print()

make_agent/app_dirs.py

@@ -0,0 +1,51 @@
+"""Centralised path helpers for ~/.make-agent project directories.
+
+All app-related files live under a hidden directory in the user's home folder::
+
+    ~/.make-agent/<project-slug>/agents/      # default agents directory
+    ~/.make-agent/<project-slug>/logs/        # log files
+
+The *project slug* is derived from the absolute working directory by stripping
+the leading ``/`` and replacing every remaining ``/`` with ``_``.
+
+Example:  ``/Users/alice/proj/myapp``  →  ``Users_alice_proj_myapp``
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+_APP_HOME = Path.home() / ".make-agent"
+
+
+def project_slug(cwd: str | None = None) -> str:
+    """Return the project slug for *cwd* (defaults to ``os.getcwd()``)."""
+    path = cwd or os.getcwd()
+    return path.lstrip("/").replace("/", "_")
+
+
+def project_dir(cwd: str | None = None) -> Path:
+    """Return ``~/.make-agent/<slug>/``, creating it if necessary."""
+    directory = _APP_HOME / project_slug(cwd)
+    directory.mkdir(parents=True, exist_ok=True)
+    return directory
+
+
+def default_agents_dir(cwd: str | None = None) -> str:
+    """Return ``~/.make-agent/<slug>/agents/`` as a string, creating it if necessary."""
+    directory = project_dir(cwd) / "agents"
+    directory.mkdir(parents=True, exist_ok=True)
+    return str(directory)
+
+
+def log_file(cwd: str | None = None) -> str:
+    """Return ``~/.make-agent/<slug>/logs/make-agent.log`` as a string, creating the logs dir if necessary."""
+    logs_dir = project_dir(cwd) / "logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    return str(logs_dir / "make-agent.log")
+
+
+def settings_file(cwd: str | None = None) -> Path:
+    """Return ``~/.make-agent/<slug>/settings.yaml`` as a Path (does not create the file)."""
+    return project_dir(cwd) / "settings.yaml"