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

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

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

{makefile_agent-0.4.2 → 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.2 → 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
@@ -94,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:
@@ -117,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)
 
@@ -231,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.2 → makefile_agent-0.4.3}/make_agent/skill_backend.py

@@ -32,13 +32,17 @@ 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),
+            "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
             ),

{makefile_agent-0.4.2 → 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.2
+Version: 0.4.3
 Summary: An AI agent powered by Makefile skills.
 Author: Dmitriy Sorochenkov
 License-Expression: MIT

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

@@ -48,6 +48,7 @@ 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

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

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

makefile_agent-0.4.3/tests/test_enabled_skills.py

@@ -0,0 +1,210 @@
+"""Tests for the --enabled-skills CLI feature."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from unittest.mock import patch
+
+import make_agent.main as main_module
+from make_agent.builtin_tools.skill_tools import list_skills
+from make_agent.main import _discover_skill_names
+from make_agent.skill_backend import MakefileSkillBackend
+
+_SKILL_MK = """\
+define DESCRIPTION
+A test skill
+endef
+
+.PHONY: greet
+greet:
+@echo hello
+"""
+
+
+class TestParseEnabledSkills:
+    def test_none_returns_none(self):
+        assert main_module._parse_enabled_skills(None, frozenset()) is None
+
+    def test_comma_separated_list(self):
+        all_names = frozenset({"git", "run", "file-list"})
+        result = main_module._parse_enabled_skills("git,run", all_names)
+        assert result == frozenset({"git", "run"})
+
+    def test_single_name(self):
+        result = main_module._parse_enabled_skills("git", frozenset({"git"}))
+        assert result == frozenset({"git"})
+
+    def test_unknown_name_exits(self):
+        all_names = frozenset({"git", "run"})
+        with patch.object(sys, "exit", side_effect=SystemExit) as mock_exit:
+            try:
+                main_module._parse_enabled_skills("ghost", all_names)
+            except SystemExit:
+                pass
+        mock_exit.assert_called_once()
+
+    def test_whitespace_stripped(self):
+        result = main_module._parse_enabled_skills(
+            " git , run ", frozenset({"git", "run"})
+        )
+        assert result == frozenset({"git", "run"})
+
+
+class TestDiscoverSkillNames:
+    def test_missing_dir(self, tmp_path):
+        assert _discover_skill_names(str(tmp_path / "nonexistent")) == []
+
+    def test_empty_dir(self, tmp_path):
+        assert _discover_skill_names(str(tmp_path)) == []
+
+    def test_returns_sorted_names(self, tmp_path):
+        (tmp_path / "zzz").mkdir()
+        (tmp_path / "zzz" / "skill.mk").write_text(_SKILL_MK)
+        (tmp_path / "aaa").mkdir()
+        (tmp_path / "aaa" / "skill.mk").write_text(_SKILL_MK)
+        assert _discover_skill_names(str(tmp_path)) == ["aaa", "zzz"]
+
+
+class TestListSkillsFiltering:
+    def test_no_filter_shows_all(self, tmp_path):
+        for name in ("git", "run", "file-list"):
+            (tmp_path / name).mkdir()
+            (tmp_path / name / "skill.mk").write_text(_SKILL_MK)
+        result = list_skills(str(tmp_path))
+        assert "git:" in result
+        assert "run:" in result
+        assert "file-list:" in result
+
+    def test_subset_filters_correctly(self, tmp_path):
+        for name in ("git", "run", "file-list"):
+            (tmp_path / name).mkdir()
+            (tmp_path / name / "skill.mk").write_text(_SKILL_MK)
+        result = list_skills(
+            str(tmp_path), enabled_skills=frozenset({"git", "file-list"})
+        )
+        assert "git:" in result
+        assert "file-list:" in result
+        assert "run:" not in result
+
+    def test_empty_result_when_none_match(self, tmp_path):
+        (tmp_path / "git").mkdir()
+        (tmp_path / "git" / "skill.mk").write_text(_SKILL_MK)
+        result = list_skills(str(tmp_path), enabled_skills=frozenset({"ghost"}))
+        assert "No skills found" in result
+
+
+class TestBackendIntegration:
+    def test_list_skills_filtered(self, tmp_path):
+        for name in ("git", "run"):
+            (tmp_path / name).mkdir()
+            (tmp_path / name / "skill.mk").write_text(_SKILL_MK)
+        backend = MakefileSkillBackend(str(tmp_path), enabled_skills=frozenset({"git"}))
+        result = backend.executors["list_skills"]()
+        assert "git:" in result
+        assert "run:" not in result
+
+    def test_default_no_filter(self, tmp_path):
+        """When enabled_skills is None (default), all skills work."""
+        (tmp_path / "git").mkdir()
+        (tmp_path / "git" / "skill.mk").write_text(_SKILL_MK)
+        backend = MakefileSkillBackend(str(tmp_path))  # no enabled_skills
+        result = backend.executors["list_skills"]()
+        assert "git:" in result
+
+
+class TestCmdRunWithEnabledSkills:
+    def test_enabled_skills_passed_to_backend(self, tmp_path):
+        # _cmd_run appends /makefile to the skills_dir, so create there.
+        skills_dir = tmp_path / "skills" / "makefile"
+        skills_dir.mkdir(parents=True)
+        (skills_dir / "git").mkdir()
+        (skills_dir / "git" / "skill.mk").write_text(_SKILL_MK)
+        (skills_dir / "run").mkdir()
+        (skills_dir / "run" / "skill.mk").write_text(_SKILL_MK)
+
+        args = _run_args(
+            prompt="do it",
+            skills_dir=str(tmp_path / "skills"),
+            enabled_skills="git",
+        )
+        captured: dict = {}
+
+        async def _fake_run(**kwargs):
+            captured.update(kwargs)
+
+        with (
+            patch.object(main_module, "run", _fake_run),
+            patch.object(main_module, "ensure_mode_system_prompt"),
+            patch.object(
+                main_module, "mode_dir", return_value=tmp_path / "makefile-mode"
+            ),
+            patch.object(
+                main_module,
+                "mode_memory_path",
+                return_value=tmp_path / "makefile-memory.db",
+            ),
+        ):
+            main_module._cmd_run(args)
+
+        backend = captured["tool_handler"]._backend
+        assert isinstance(backend, MakefileSkillBackend)
+        result = backend.executors["list_skills"]()
+        assert "git:" in result
+        assert "run:" not in result
+
+    def test_no_enabled_skills_flag_passes_none(self, tmp_path):
+        # _cmd_run appends /makefile to the skills_dir, so create there.
+        skills_dir = tmp_path / "skills" / "makefile"
+        skills_dir.mkdir(parents=True)
+        (skills_dir / "git").mkdir()
+        (skills_dir / "git" / "skill.mk").write_text(_SKILL_MK)
+
+        args = _run_args(prompt="do it", skills_dir=str(tmp_path / "skills"))
+        captured: dict = {}
+
+        async def _fake_run(**kwargs):
+            captured.update(kwargs)
+
+        with (
+            patch.object(main_module, "run", _fake_run),
+            patch.object(main_module, "ensure_mode_system_prompt"),
+            patch.object(
+                main_module, "mode_dir", return_value=tmp_path / "makefile-mode"
+            ),
+            patch.object(
+                main_module,
+                "mode_memory_path",
+                return_value=tmp_path / "makefile-memory.db",
+            ),
+        ):
+            main_module._cmd_run(args)
+
+        backend = captured["tool_handler"]._backend
+        assert isinstance(backend, MakefileSkillBackend)
+        # None means all skills enabled
+        result = backend.executors["list_skills"]()
+        assert "git:" in result
+
+
+def _run_args(**kwargs) -> argparse.Namespace:
+    defaults = dict(
+        model="model-x",
+        prompt=None,
+        prompt_file=None,
+        system=None,
+        system_file=None,
+        max_retries=5,
+        tool_timeout=600,
+        max_tool_output=20000,
+        max_tokens=4096,
+        skills_dir=None,
+        disable_builtin_tools=None,
+        reasoning_effort="auto",
+        skill_mode="makefile",
+        prompt_cache=False,
+        compact_mode="drop",
+        enabled_skills=None,
+    )
+    defaults.update(kwargs)
+    return argparse.Namespace(**defaults)

{makefile_agent-0.4.2 → makefile_agent-0.4.3}/tests/test_main.py

@@ -44,6 +44,7 @@ def _run_args(**kwargs) -> argparse.Namespace:
         skill_mode="makefile",  # noqa: S106 - kept for test compatibility
         prompt_cache=False,
         compact_mode="drop",
+        enabled_skills=None,
     )
     defaults.update(kwargs)
     return argparse.Namespace(**defaults)