makefile-agent 0.4.1__tar.gz → 0.4.3__tar.gz

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makefile-agent
-Version: 0.4.1
+Version: 0.4.3
 Summary: An AI agent powered by Makefile skills.
 Author: Dmitriy Sorochenkov
 License-Expression: MIT

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/agent_core/agent.py

@@ -67,7 +67,9 @@ class AgentManager:
         middlewares: list[MiddlewareBase] | None = None,
     ) -> None:
         self._tool_handler = tool_handler
-        self._middlewares: list[MiddlewareBase] = middlewares if middlewares is not None else []
+        self._middlewares: list[MiddlewareBase] = (
+            middlewares if middlewares is not None else []
+        )
         self._sessions: dict[str, AgenticLoop] = {}
 
     @staticmethod
@@ -103,11 +105,15 @@ class AgentManager:
         async for event in self._run_loop(loop, request.message):
             yield event
 
-    async def _run_loop(self, loop: AgenticLoop, message: str) -> AsyncIterator[AgentEvent]:
+    async def _run_loop(
+        self, loop: AgenticLoop, message: str
+    ) -> AsyncIterator[AgentEvent]:
         """Iterate one agent turn, translating callbacks to AgentEvents."""
         async for cb in loop.astream(message):
             if isinstance(cb, CompactCallback):
-                yield CompactEvent(attempt=cb.attempt, messages_dropped=cb.messages_dropped)
+                yield CompactEvent(
+                    attempt=cb.attempt, messages_dropped=cb.messages_dropped
+                )
             elif isinstance(cb, TokenCallback):
                 yield TokenEvent(text=cb.message)
             elif isinstance(cb, MessageCallback):
@@ -121,10 +127,14 @@ class AgentManager:
             elif isinstance(cb, ToolCallback):
                 if cb.tool_name == "execute_skill":
                     skill_name = cb.tool_args.get("name", "")
-                    target = cb.tool_args.get("target") or cb.tool_args.get("command", "")
+                    target = cb.tool_args.get("target") or cb.tool_args.get(
+                        "command", ""
+                    )
                     if not self._tool_handler.is_skill_trusted(skill_name, target):
                         kwargs = cb.tool_args.get("kwargs") or {}
-                        confirm = ConfirmEvent(skill_name=skill_name, target=target, kwargs=kwargs)
+                        confirm = ConfirmEvent(
+                            skill_name=skill_name, target=target, kwargs=kwargs
+                        )
                         yield confirm
                         allowed = await confirm.wait()
                         if not allowed:
@@ -137,7 +147,9 @@ class AgentManager:
                     description=cb.description,
                 )
                 start_time = time.monotonic()
-                result = await self._tool_handler.execute(cb.tool_name, cb.tool_args, loop._max_tool_output)
+                result = await self._tool_handler.execute(
+                    cb.tool_name, cb.tool_args, loop._max_tool_output
+                )
                 cb.set_response(result.output, is_error=result.is_error)
                 duration_ms = (time.monotonic() - start_time) * 1000
                 cb.duration_ms = duration_ms
@@ -150,7 +162,9 @@ class AgentManager:
 
     def _build_chain(self) -> Callable[[Request], AsyncIterator[AgentEvent]]:
         """Build the middleware chain; first middleware in the list is innermost."""
-        current: Callable[[Request], AsyncIterator[AgentEvent]] = self._stream_events_core
+        current: Callable[[Request], AsyncIterator[AgentEvent]] = (
+            self._stream_events_core
+        )
         for mw in self._middlewares:
             prev = current
 
@@ -163,7 +177,9 @@ class AgentManager:
             current = make_wrapper(mw, prev)
         return current
 
-    async def astream_events(self, session_id: str, message: str) -> AsyncIterator[AgentEvent]:
+    async def astream_events(
+        self, session_id: str, message: str
+    ) -> AsyncIterator[AgentEvent]:
         """Stream :class:`AgentEvent` objects for one agent turn.
 
         Tool execution and skill confirmation are handled internally.
@@ -266,14 +282,20 @@ class AgentManager:
                 if active_turn_task and not active_turn_task.done():
                     active_turn_task.cancel()
                 else:
-                    await event_queue.put(ManagerError(message="No active turn to cancel"))
+                    await event_queue.put(
+                        ManagerError(message="No active turn to cancel")
+                    )
 
             elif isinstance(cmd, (ApproveSkill, DenySkill)):
                 future = pending_approvals.pop(cmd.request_id, None)
                 if future and not future.done():
                     future.set_result(isinstance(cmd, ApproveSkill))
                 else:
-                    await event_queue.put(ManagerError(message=f"Unknown approval request: {cmd.request_id}"))
+                    await event_queue.put(
+                        ManagerError(
+                            message=f"Unknown approval request: {cmd.request_id}"
+                        )
+                    )
 
     async def _execute_bridge_turn(
         self,
@@ -291,7 +313,9 @@ class AgentManager:
         try:
             async for event in self.astream_events(session_id, message):
                 if isinstance(event, TokenEvent):
-                    await event_queue.put(TokenEmitted(turn_id=turn_id, text=event.text))
+                    await event_queue.put(
+                        TokenEmitted(turn_id=turn_id, text=event.text)
+                    )
                 elif isinstance(event, ToolStartEvent):
                     current_tool_id = str(uuid4())
                     await event_queue.put(

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/agent_shell/run.py

@@ -73,6 +73,7 @@ async def run(
         session_id,
         model=model,
         history_path=project_dir() / "history",
+        memory=memory,
     )
     try:
         await shell.run()

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/agent_shell/shell.py

@@ -19,16 +19,6 @@ from pathlib import Path
 from typing import Any, Optional
 from uuid import uuid4
 
-from prompt_toolkit.application import Application
-from prompt_toolkit.completion import WordCompleter
-from prompt_toolkit.filters import Condition
-from prompt_toolkit.history import FileHistory
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.layout import HSplit, Layout, VSplit, Window
-from prompt_toolkit.layout.controls import FormattedTextControl
-from prompt_toolkit.styles import Style
-from prompt_toolkit.widgets import Frame, TextArea
-
 from make_agent.agent_core import (
     AgentManager,
     ApprovalRequested,
@@ -42,14 +32,24 @@ from make_agent.agent_core import (
     Shutdown,
     StartTurn,
     StatusChanged,
+    TokenEmitted,
     ToolFinished,
     ToolStarted,
-    TokenEmitted,
     TurnCancelled,
     TurnFinished,
     TurnStarted,
 )
+from make_agent.memory import Memory
+from prompt_toolkit.application import Application
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import HSplit, Layout, VSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.styles import Style
+from prompt_toolkit.widgets import Frame, TextArea
 
+from .user_messages import UserMessagesManager
 
 # ── status / enums ──────────────────────────────────────────────────────────────
 
@@ -299,6 +299,7 @@ class MakeAgentShell:
         session_id: str,
         model: str,
         history_path: Path,
+        memory: Optional[Memory] = None,
     ) -> None:
         self._agent_manager = agent_manager
         self._session_id = session_id
@@ -310,6 +311,7 @@ class MakeAgentShell:
         self._app: Optional[Application] = None
         self._response_area: Optional[TextArea] = None
         self._tools_area: Optional[TextArea] = None
+        self._history_manager = UserMessagesManager(memory) if memory else None
         self._commands: dict[str, Any] = {
             "exit": self._cmd_exit,
             "quit": self._cmd_exit,
@@ -418,7 +420,6 @@ class MakeAgentShell:
             prompt="> ",
             multiline=True,
             completer=completer,
-            history=FileHistory(str(self._history_path)),
             wrap_lines=False,
         )
         self._composer_input = composer_input
@@ -474,7 +475,7 @@ class MakeAgentShell:
                         else [
                             (
                                 "class:hint",
-                                "  /help /stats /export /exit   Alt+Enter newline   Ctrl+T transcript",
+                                "  /help /stats /export /exit   ↑↓ history   Alt+Enter newline   Ctrl+T transcript",
                             )
                         ]
                     )
@@ -557,10 +558,15 @@ class MakeAgentShell:
         def _on_enter(event) -> None:
             if state.status != AgentStatus.IDLE or state.transcript_focused:
                 return
+
             text = composer_input.text.strip()
             if not text:
                 return
+
             composer_input.text = ""
+            if self._history_manager is not None:
+                self._history_manager.submit()  # Reset nav state after sending
+
             if text.startswith("/"):
                 should_exit = self._dispatch_command(text[1:])
                 if should_exit:
@@ -570,6 +576,31 @@ class MakeAgentShell:
             else:
                 asyncio.ensure_future(self._run_turn(text))
 
+        # Only bind up/down for history navigation when composer is focused,
+        # idle, and memory is available — so arrow keys still scroll the
+        # transcript area when it's focused.
+        composer_history_filter = Condition(
+            lambda: (
+                not state.transcript_focused
+                and state.status == AgentStatus.IDLE
+                and self._history_manager is not None
+            )
+        )
+
+        @kb.add("up", filter=composer_history_filter)
+        def _on_up(event) -> None:
+            msg = self._history_manager.previous(composer_input.text)
+            if msg is not None:
+                composer_input.text = msg
+                self._refresh()
+
+        @kb.add("down", filter=composer_history_filter)
+        def _on_down(event) -> None:
+            msg = self._history_manager.next()
+            if msg is not None:
+                composer_input.text = msg
+                self._refresh()
+
         @kb.add("escape", "enter")
         def _on_alt_enter(event) -> None:
             if state.status == AgentStatus.IDLE and not state.transcript_focused:

makefile_agent-0.4.3/make_agent/agent_shell/user_messages.py

@@ -0,0 +1,110 @@
+"""User message history manager for the agent shell.
+
+Provides navigation through past user messages backed by persistent Memory.
+The shell interacts with this manager, not Memory directly.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from make_agent.memory import Memory
+
+
+class UserMessagesManager:
+    """Manages user message history for shell navigation.
+
+    Refreshes messages from Memory on each navigation start so that
+    messages from the current session are always included.  Supports
+    forward/backward navigation with index tracking.
+    """
+
+    def __init__(self, memory: Memory, limit: int = 200) -> None:
+        """Initialize with a Memory instance.
+
+        Args:
+            memory: The Memory backend to fetch messages from.
+            limit: Maximum number of historical messages to load (default: 200).
+        """
+        self._memory = memory
+        self._limit = limit
+        self._messages: list[str] = []  # Refreshed on each nav start, newest first
+        self._index: int = -1  # -1 = not navigating; 0 = most recent
+        self._original_text: str = ""  # Text user had typed before pressing UP
+
+    def _refresh(self) -> None:
+        """Reload user messages from Memory so current-session messages
+        are always visible."""
+        self._messages = self._memory.recent_user(self._limit)
+
+    def start_navigating(self, current_text: str) -> Optional[str]:
+        """Begin navigation from the current composer text.
+
+        Called when user first presses UP.  Reloads messages from Memory
+        so current-session messages are included.  Saves the current text
+        as the restoration point (returned when DOWN exits navigation).
+
+        Args:
+            current_text: What the user has typed so far.
+
+        Returns:
+            The most recent past user message, or None if history is empty.
+        """
+        self._refresh()
+        if not self._messages:
+            return None
+        self._original_text = current_text
+        self._index = 0
+        return self._messages[0]
+
+    def previous(self, current_text: str = "") -> Optional[str]:
+        """Navigate to the next older message.
+
+        Args:
+            current_text: What the user has typed so far (saved as restoration point
+                          on first UP press).
+
+        Returns:
+            The previous message, or None if already at the oldest.
+        """
+        if self._index < 0:
+            # First press — start navigating, save current text as restoration point
+            return self.start_navigating(current_text)
+        if self._index < len(self._messages) - 1:
+            self._index += 1
+            return self._messages[self._index]
+        return None
+
+    def next(self) -> Optional[str]:
+        """Navigate to the next newer message or restore original text.
+
+        Returns:
+            The next newer message, or the original typed text when
+            navigation returns to the start, or None if not navigating.
+        """
+        if self._index < 0:
+            return None
+        if self._index > 0:
+            self._index -= 1
+            return self._messages[self._index]
+        # Back at start — restore original text
+        text = self._original_text
+        self._index = -1
+        self._original_text = ""
+        return text
+
+    def cancel(self) -> None:
+        """Cancel navigation and restore the original typed text."""
+        self._index = -1
+
+    def submit(self) -> None:
+        """Called when the user sends a message (presses Enter).
+
+        Resets navigation state so the next UP press starts fresh.
+        """
+        self._index = -1
+        self._original_text = ""
+
+    def is_navigating(self) -> bool:
+        """Check if the user is currently in navigation mode."""
+        return self._index >= 0

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/builtin_tools/skill_tools.py

@@ -120,16 +120,31 @@ def _skill_description(mk_path: Path) -> str:
     return "  (no description)"
 
 
-def list_skills(skills_dir: str) -> str:
-    """List all available skills with their names and descriptions."""
+def list_skills(skills_dir: str, enabled_skills: frozenset[str] | None = None) -> str:
+    """List all available skills with their names and descriptions.
+
+    If *enabled_skills* is provided and is not ``{"*"}`` or empty, only those
+    skill names are shown.  When the set contains ``"*"`` or is None, all
+    discovered skills are listed (default: show everything).
+    """
     path = Path(skills_dir)
     if not path.exists():
         return "No skills found (directory does not exist)"
-    skill_dirs = sorted(
+
+    all_skill_dirs = sorted(
         p for p in path.iterdir() if p.is_dir() and (p / "skill.mk").exists()
     )
+    if not all_skill_dirs:
+        return "No skills found"
+
+    if enabled_skills is not None:
+        skill_dirs = [sd for sd in all_skill_dirs if sd.name in enabled_skills]
+    else:
+        skill_dirs = all_skill_dirs
+
     if not skill_dirs:
         return "No skills found"
+
     entries = []
     for sd in skill_dirs:
         desc = _skill_description(sd / "skill.mk")
@@ -168,6 +183,7 @@ def execute_skill(
     injected as environment variables; tokens after ``make`` are passed as make
     arguments (targets and/or make-style variable assignments).
     """
+
     if not _valid_skill_name(name):
         return f"Error: invalid skill name {name!r}. Use letters, numbers, hyphens, underscores, and dots only."
     safe_paths = _resolve_safe_skill_path(skills_dir, name, "skill.mk")

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/main.py

@@ -10,6 +10,7 @@ from make_agent.agent_core import (
     DEFAULT_COMPACT_MODE,
     DEFAULT_MAX_TOKENS,
     DEFAULT_MAX_TOOL_OUTPUT,
+    DEFAULT_TOOL_TIMEOUT,
     DEFAULT_USE_PROMPT_CACHE,
 )
 from make_agent.agent_shell import run
@@ -37,7 +38,9 @@ def _init_logging(loglevel: str) -> None:
     # Remove any existing root handlers so basicConfig always adds our file handler.
     for h in logging.root.handlers[:]:
         logging.root.removeHandler(h)
-    logging.basicConfig(filename=log_file(), level=level, format="%(asctime)s %(levelname)s %(message)s")
+    logging.basicConfig(
+        filename=log_file(), level=level, format="%(asctime)s %(levelname)s %(message)s"
+    )
 
 
 def _resolve_system_prompt(args: argparse.Namespace) -> str:
@@ -76,7 +79,10 @@ def _parse_disabled_tools(value: str | None, mode: str) -> frozenset[str]:
     names = frozenset(name.strip() for name in value.split(",") if name.strip())
     unknown = names - available
     if unknown:
-        sys.exit("make-agent: unknown built-in tool(s): " f"{', '.join(sorted(unknown))}. Valid names for {mode}: {', '.join(sorted(available))}")
+        sys.exit(
+            "make-agent: unknown built-in tool(s): "
+            f"{', '.join(sorted(unknown))}. Valid names for {mode}: {', '.join(sorted(available))}"
+        )
     return names
 
 
@@ -89,8 +95,36 @@ def _parse_trusted_skills(value: str | None) -> frozenset[str]:
     return frozenset(name.strip() for name in value.split(",") if name.strip())
 
 
-def _build_backend(skill_mode: str, skills_dir: str, tool_timeout: int):
-    return MakefileSkillBackend(skills_dir, tool_timeout, Path.cwd())
+def _parse_enabled_skills(
+    value: str | None, all_names: frozenset[str]
+) -> frozenset[str] | None:
+    """Parse --enabled-skills into a frozenset.
+
+    Returns None when the user didn't pass the flag (meaning: use all discovered skills).
+    When the flag is passed, returns the parsed set. 'all' maps to * (keep all).
+    Raises sys.exit on unknown skill names.
+    """
+    if not value:
+        return None
+
+    names = frozenset(name.strip() for name in value.split(",") if name.strip())
+    unknown = names - all_names
+    if unknown:
+        sys.exit(
+            "make-agent: unknown skill(s): "
+            f"{', '.join(sorted(unknown))}. Valid names: {', '.join(sorted(all_names))}"
+        )
+    return names
+
+
+def _discover_skill_names(skills_dir: str) -> list[str]:
+    """Return a sorted list of all discoverable skill names from *skills_dir*."""
+    path = Path(skills_dir)
+    if not path.exists():
+        return []
+    return sorted(
+        p.name for p in path.iterdir() if p.is_dir() and (p / "skill.mk").exists()
+    )
 
 
 def _cmd_run(args: argparse.Namespace) -> None:
@@ -112,8 +146,13 @@ def _cmd_run(args: argparse.Namespace) -> None:
     else:
         skills_dir = str(default_skills_dir(_SKILL_MODE))
 
+    all_names = _discover_skill_names(skills_dir)
+    enabled_skills = _parse_enabled_skills(args.enabled_skills, frozenset(all_names))
+
     memory = Memory(mode_memory_path(_SKILL_MODE))
-    backend = _build_backend(_SKILL_MODE, skills_dir, args.tool_timeout)
+    backend = MakefileSkillBackend(
+        skills_dir, DEFAULT_TOOL_TIMEOUT, Path.cwd(), enabled_skills
+    )
     trusted_skills = _parse_trusted_skills(getattr(args, "trusted_skills", None))
     tool_handler = ToolHandler(backend, memory, disabled, trusted_skills)
 
@@ -143,7 +182,9 @@ def main() -> None:
     subparsers = parser.add_subparsers(dest="command")
 
     run_p = subparsers.add_parser("run", help="Start the interactive agent (default)")
-    run_p.add_argument("--model", default=None, metavar="MODEL", help="litellm model string (required)")
+    run_p.add_argument(
+        "--model", default=None, metavar="MODEL", help="litellm model string (required)"
+    )
     system_g = run_p.add_mutually_exclusive_group()
     system_g.add_argument(
         "--system",
@@ -224,6 +265,12 @@ def main() -> None:
         metavar="EFFORT",
         help=f"Reasoning effort level ({'/'.join(_REASONING_EFFORT_VALUES)}, default: auto)",
     )
+    run_p.add_argument(
+        "--enabled-skills",
+        default=None,
+        metavar="SKILLS",
+        help="Comma-separated skill names to enable. By default all discovered skills are enabled.",
+    )
     run_p.add_argument(
         "--trusted-skills",
         default=None,

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/memory/memory.py

@@ -216,6 +216,21 @@ class Memory:
         """Search past agent replies using FTS5 via the ``agent_memory`` view."""
         return self._search("agent_memory", query, limit, from_date, to_date)
 
+    def recent_user(
+        self,
+        limit: int = 10,
+    ) -> list[str]:
+        """Return the *limit* most recent user messages as plain strings, newest first.
+
+        Used by the shell for UP/DOWN arrow navigation through past user messages.
+        """
+        conn = self._get_conn()
+        rows = conn.execute(
+            "SELECT message FROM messages WHERE sender = 'user' ORDER BY id DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+        return [row["message"] for row in rows]
+
     def recent(
         self,
         limit: int = 10,

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/skill_backend.py

@@ -11,7 +11,9 @@ from make_agent.builtin_tools.skill_tools import create_skill as create_makefile
 from make_agent.builtin_tools.skill_tools import execute_skill as execute_makefile_skill
 from make_agent.builtin_tools.skill_tools import list_skills as list_makefile_skills
 from make_agent.builtin_tools.skill_tools import read_skill as read_makefile_skill
-from make_agent.builtin_tools.skill_tools import validate_skill as validate_makefile_skill
+from make_agent.builtin_tools.skill_tools import (
+    validate_skill as validate_makefile_skill,
+)
 
 
 class SkillBackend(Protocol):
@@ -30,14 +32,20 @@ class MakefileSkillBackend:
         skills_dir: str,
         tool_timeout: int = 600,
         base_dir: Path | None = None,
+        enabled_skills: frozenset[str] | None = None,
     ) -> None:
         self._skills_dir = skills_dir
         self._tool_timeout = tool_timeout
         self._base_dir = base_dir if base_dir is not None else Path.cwd()
+        self._enabled_skills = enabled_skills
         self._schemas = MAKEFILE_SKILL_SCHEMAS + FILE_SCHEMAS
         self._executors: dict[str, Any] = {
-            "list_skills": lambda **_kw: list_makefile_skills(self._skills_dir),
-            "read_skill": lambda name, **_kw: read_makefile_skill(name, self._skills_dir),
+            "list_skills": lambda **_kw: list_makefile_skills(
+                self._skills_dir, self._enabled_skills
+            ),
+            "read_skill": lambda name, **_kw: read_makefile_skill(
+                name, self._skills_dir
+            ),
             "execute_skill": lambda name, command, **_kw: execute_makefile_skill(
                 name,
                 command,

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/make_agent/tool_handler/handler.py

@@ -26,12 +26,28 @@ class ToolHandler:
         disabled: frozenset[str] = frozenset(),
         trusted_skills: frozenset[str] = frozenset(),
     ) -> None:
-        active_backend_schemas = [schema for schema in backend.schemas if schema["function"]["name"] not in disabled]
-        active_memory_schemas = [schema for schema in MEMORY_SCHEMAS if schema["function"]["name"] not in disabled]
+        active_backend_schemas = [
+            schema
+            for schema in backend.schemas
+            if schema["function"]["name"] not in disabled
+        ]
+        active_memory_schemas = [
+            schema
+            for schema in MEMORY_SCHEMAS
+            if schema["function"]["name"] not in disabled
+        ]
         self._schemas: list[dict] = active_backend_schemas + active_memory_schemas
         self._executors: dict[str, Any] = {
-            **{name: executor for name, executor in backend.executors.items() if name not in disabled},
-            **{name: executor for name, executor in get_memory_executors(memory).items() if name not in disabled},
+            **{
+                name: executor
+                for name, executor in backend.executors.items()
+                if name not in disabled
+            },
+            **{
+                name: executor
+                for name, executor in get_memory_executors(memory).items()
+                if name not in disabled
+            },
         }
         self._backend = backend
         self._trusted_skills = trusted_skills

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/makefile_agent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makefile-agent
-Version: 0.4.1
+Version: 0.4.3
 Summary: An AI agent powered by Makefile skills.
 Author: Dmitriy Sorochenkov
 License-Expression: MIT

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/makefile_agent.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ make_agent/agent_core/provider.py
 make_agent/agent_shell/__init__.py
 make_agent/agent_shell/run.py
 make_agent/agent_shell/shell.py
+make_agent/agent_shell/user_messages.py
 make_agent/builtin_tools/__init__.py
 make_agent/builtin_tools/file_tools.py
 make_agent/builtin_tools/skill_tools.py
@@ -47,9 +48,11 @@ tests/test_bridge.py
 tests/test_builtin_tools.py
 tests/test_commands.py
 tests/test_compact.py
+tests/test_enabled_skills.py
 tests/test_main.py
 tests/test_memory.py
 tests/test_middleware.py
 tests/test_parser.py
 tests/test_tools.py
-tests/test_trusted_skill.py
+tests/test_trusted_skill.py
+tests/test_user_messages.py

{makefile_agent-0.4.1 → makefile_agent-0.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "makefile-agent"
-version = "0.4.1"
+version = "0.4.3"
 description = "An AI agent powered by Makefile skills."
 readme = "README.md"
 license = "MIT"