kagent-skills 0.7.13__tar.gz

kagent_skills-0.7.13/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: kagent-skills
+Version: 0.7.13
+Summary: Core library for discovering and loading KAgent skills.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# KAgent Skills
+
+Core library for discovering, parsing, and loading KAgent skills from the filesystem.
+
+For example usage, see `kagent-adk` and `kagent-openai` packages.

kagent_skills-0.7.13/README.md

@@ -0,0 +1,5 @@
+# KAgent Skills
+
+Core library for discovering, parsing, and loading KAgent skills from the filesystem.
+
+For example usage, see `kagent-adk` and `kagent-openai` packages.

kagent_skills-0.7.13/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "kagent-skills"
+version = "0.7.13"
+description = "Core library for discovering and loading KAgent skills."
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+  "pydantic>=2.0.0",
+  "pyyaml>=6.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/kagent"]
+
+[tool.black]
+line-length = 120
+target-version = ['py313']
+
+[tool.ruff]
+line-length = 120
+target-version = "py313"
+lint.select = ["E", "F", "I", "N", "W", "UP"]
+lint.ignore = ["E501", "N803", "N806"]

kagent_skills-0.7.13/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

kagent_skills-0.7.13/src/kagent/skills/__init__.py

@@ -0,0 +1,38 @@
+from .discovery import discover_skills, load_skill_content
+from .models import Skill
+from .prompts import (
+    generate_skills_tool_description,
+    get_bash_description,
+    get_edit_file_description,
+    get_read_file_description,
+    get_write_file_description,
+)
+from .session import (
+    clear_session_cache,
+    get_session_path,
+    initialize_session_path,
+)
+from .shell import (
+    edit_file_content,
+    execute_command,
+    read_file_content,
+    write_file_content,
+)
+
+__all__ = [
+    "discover_skills",
+    "load_skill_content",
+    "Skill",
+    "read_file_content",
+    "write_file_content",
+    "edit_file_content",
+    "execute_command",
+    "generate_skills_tool_description",
+    "get_read_file_description",
+    "get_write_file_description",
+    "get_edit_file_description",
+    "get_bash_description",
+    "initialize_session_path",
+    "get_session_path",
+    "clear_session_cache",
+]

kagent_skills-0.7.13/src/kagent/skills/discovery.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import yaml
+
+from .models import Skill
+
+logger = logging.getLogger(__name__)
+
+
+def parse_skill_metadata(skill_file: Path) -> dict[str, str] | None:
+    """Parse YAML frontmatter from a SKILL.md file."""
+    try:
+        with open(skill_file, encoding="utf-8") as f:
+            content = f.read()
+
+        if not content.startswith("---"):
+            return None
+
+        parts = content.split("---", 2)
+        if len(parts) < 3:
+            return None
+
+        metadata = yaml.safe_load(parts[1])
+        if isinstance(metadata, dict) and "name" in metadata and "description" in metadata:
+            return {
+                "name": metadata["name"],
+                "description": metadata["description"],
+            }
+        return None
+    except Exception as e:
+        logger.error(f"Failed to parse metadata from {skill_file}: {e}")
+        return None
+
+
+def discover_skills(skills_directory: Path) -> list[Skill]:
+    """Discover available skills and return their metadata."""
+    if not skills_directory.exists():
+        logger.warning(f"Skills directory not found: {skills_directory}")
+        return []
+
+    skills = []
+    for skill_dir in sorted(skills_directory.iterdir()):
+        if not skill_dir.is_dir():
+            continue
+
+        skill_file = skill_dir / "SKILL.md"
+        if not skill_file.exists():
+            continue
+
+        try:
+            metadata = parse_skill_metadata(skill_file)
+            if metadata:
+                skills.append(Skill(**metadata))
+        except Exception as e:
+            logger.error(f"Failed to parse skill {skill_dir.name}: {e}")
+
+    return skills
+
+
+def load_skill_content(skills_directory: Path, skill_name: str) -> str:
+    """Load and return the full content of a skill's SKILL.md file."""
+    # Find skill directory
+    skill_dir = skills_directory / skill_name
+    if not skill_dir.exists() or not skill_dir.is_dir():
+        raise FileNotFoundError(f"Skill '{skill_name}' not found in {skills_directory}")
+
+    skill_file = skill_dir / "SKILL.md"
+    if not skill_file.exists():
+        raise FileNotFoundError(f"Skill '{skill_name}' has no SKILL.md file in {skill_dir}")
+
+    try:
+        with open(skill_file, encoding="utf-8") as f:
+            content = f.read()
+        return content
+    except Exception as e:
+        logger.error(f"Failed to load skill {skill_name}: {e}")
+        raise OSError(f"Error loading skill '{skill_name}': {e}") from e

kagent_skills-0.7.13/src/kagent/skills/models.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Skill(BaseModel):
+    """Represents the metadata for a skill.
+
+    This is a simple data container used during the initial skill discovery
+    phase to hold the information parsed from a skill's SKILL.md frontmatter.
+    """
+
+    name: str
+    """The unique name/identifier of the skill."""
+
+    description: str
+    """A description of what the skill does and when to use it."""
+
+    license: str | None = None
+    """Optional license information for the skill."""

kagent_skills-0.7.13/src/kagent/skills/prompts.py

@@ -0,0 +1,116 @@
+from .models import Skill
+
+
+def generate_skills_xml(skills: list[Skill]) -> str:
+    """Formats a list of skills into an XML block for tool descriptions."""
+    if not skills:
+        return "<available_skills>\n<!-- No skills found -->\n</available_skills>"
+
+    skills_entries = []
+    for skill in skills:
+        skill_xml = f"<skill>\n<name>{skill.name}</name>\n<description>{skill.description}</description>\n</skill>"
+        skills_entries.append(skill_xml)
+
+    return "<available_skills>\n" + "\n".join(skills_entries) + "\n</available_skills>"
+
+
+def generate_skills_tool_description(skills: list[Skill]) -> str:
+    """Generates the full, standardized description for the 'skills' tool."""
+    skills_xml = generate_skills_xml(skills)
+
+    # This description is based on the ADK version, which is the source of truth.
+    description = f"""Execute a skill within the main conversation
+
+<skills_instructions>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke skills using this tool with the skill name only (no arguments)
+- When you invoke a skill, the skill's full SKILL.md will load with detailed instructions
+- Follow the skill's instructions and use the bash tool to execute commands
+- Examples:
+  - command: \"data-analysis\" - invoke the data-analysis skill
+  - command: \"pdf-processing\" - invoke the pdf-processing skill
+
+Important:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in the conversation
+- After loading a skill, use the bash tool for execution
+- If not specified, scripts are located in the skill-name/scripts subdirectory
+</skills_instructions>
+
+{skills_xml}
+"""
+    return description
+
+
+def get_read_file_description() -> str:
+    """Returns the standardized description for the read_file tool."""
+    return """Reads a file from the filesystem with line numbers.
+
+Usage:
+- Provide a path to the file (absolute or relative to your working directory)
+- Returns content with line numbers (format: LINE_NUMBER|CONTENT)
+- Optional offset and limit parameters for reading specific line ranges
+- Lines longer than 2000 characters are truncated
+- Always read a file before editing it
+- You can read from skills/ directory, uploads/, outputs/, or any file in your session
+"""
+
+
+def get_write_file_description() -> str:
+    """Returns the standardized description for the write_file tool."""
+    return """Writes content to a file on the filesystem.
+
+Usage:
+- Provide a path (absolute or relative to working directory) and content to write
+- Overwrites existing files
+- Creates parent directories if needed
+- For existing files, read them first using read_file
+- Prefer editing existing files over writing new ones
+- You can write to your working directory, outputs/, or any writable location
+- Note: skills/ directory is read-only
+"""
+
+
+def get_edit_file_description() -> str:
+    """Returns the standardized description for the edit_file tool."""
+    return """Performs exact string replacements in files.
+
+Usage:
+- You must read the file first using read_file
+- Provide path (absolute or relative to working directory)
+- When editing, preserve exact indentation from the file content
+- Do NOT include line number prefixes in old_string or new_string
+- old_string must be unique unless replace_all=true
+- Use replace_all to rename variables/strings throughout the file
+- old_string and new_string must be different
+- Note: skills/ directory is read-only
+"""
+
+
+def get_bash_description() -> str:
+    """Returns the standardized description for the bash tool."""
+    # This combines the useful parts from both ADK and OpenAI descriptions
+    return """Execute bash commands in the skills environment with sandbox protection.
+
+Working Directory & Structure:
+- Commands run in a temporary session directory: /tmp/kagent/{session_id}/
+- /skills -> All skills are available here (read-only).
+- Your current working directory and /skills are added to PYTHONPATH.
+
+Python Imports (CRITICAL):
+- To import from a skill, use the name of the skill.
+  Example: from skills_name.module import function
+- If the skills name contains a dash '-', you need to use importlib to import it.
+  Example:
+    import importlib
+    skill_module = importlib.import_module('skill-name.module')
+
+For file operations:
+- Use read_file, write_file, and edit_file for interacting with the filesystem.
+
+Timeouts:
+- python scripts: 60s
+- other commands: 30s
+"""

kagent_skills-0.7.13/src/kagent/skills/session.py

@@ -0,0 +1,97 @@
+"""Manages isolated filesystem paths for agent sessions."""
+
+import logging
+import tempfile
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Cache of initialized session paths to avoid re-creating symlinks
+_session_path_cache: dict[str, Path] = {}
+
+
+def initialize_session_path(session_id: str, skills_directory: str) -> Path:
+    """Initialize a session's working directory with skills symlink.
+
+    Creates the directory structure and symlink to the skills directory.
+
+    Directory structure:
+        /tmp/kagent/{session_id}/
+        ├── skills/     -> symlink to skills_directory (read-only shared skills)
+        ├── uploads/    -> staged user files (temporary)
+        └── outputs/    -> generated files for return
+
+    Args:
+        session_id: The unique ID of the current session.
+        skills_directory: Path to the shared skills directory.
+
+    Returns:
+        The resolved path to the session's root directory.
+    """
+    # Return cached path if already initialized
+    if session_id in _session_path_cache:
+        return _session_path_cache[session_id]
+
+    # Initialize new session path
+    base_path = Path(tempfile.gettempdir()) / "kagent"
+    session_path = base_path / session_id
+
+    # Create working directories
+    (session_path / "uploads").mkdir(parents=True, exist_ok=True)
+    (session_path / "outputs").mkdir(parents=True, exist_ok=True)
+
+    # Create symlink to skills directory
+    skills_mount = Path(skills_directory)
+    skills_link = session_path / "skills"
+    if skills_mount.exists() and not skills_link.exists():
+        try:
+            skills_link.symlink_to(skills_mount)
+            logger.debug(f"Created symlink: {skills_link} -> {skills_mount}")
+        except FileExistsError:
+            # Symlink already exists (race condition from concurrent session setup)
+            pass
+        except Exception as e:
+            # Log but don't fail - skills can still be accessed via absolute path
+            logger.warning(f"Failed to create skills symlink for session {session_id}: {e}")
+
+    # Cache and return
+    resolved_path = session_path.resolve()
+    _session_path_cache[session_id] = resolved_path
+    return resolved_path
+
+
+def get_session_path(session_id: str) -> Path:
+    """Get the working directory path for a session.
+
+    This function retrieves the cached session path. If the session hasn't been
+    initialized, it falls back to auto-initialization with default /skills directory.
+
+    Args:
+        session_id: The unique ID of the current session.
+
+    Returns:
+        The resolved path to the session's root directory.
+    """
+    # Return cached path if already initialized
+    if session_id in _session_path_cache:
+        return _session_path_cache[session_id]
+
+    # Fallback: auto-initialize with default /skills
+    logger.warning(
+        f"Session {session_id} not initialized. "
+        f"Auto-initializing with default /skills. "
+        f"For custom skills directories, ensure the executor performs initialization."
+    )
+    return initialize_session_path(session_id, "/skills")
+
+
+def clear_session_cache(session_id: str | None = None) -> None:
+    """Clear cached session path(s).
+
+    Args:
+        session_id: Specific session to clear. If None, clears all cached sessions.
+    """
+    if session_id:
+        _session_path_cache.pop(session_id, None)
+    else:
+        _session_path_cache.clear()

kagent_skills-0.7.13/src/kagent/skills/shell.py

@@ -0,0 +1,175 @@
+"""Core, framework-agnostic logic for system tools (file and shell operations)."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+# --- File Operation Tools ---
+
+
+def read_file_content(
+    file_path: Path,
+    offset: int | None = None,
+    limit: int | None = None,
+) -> str:
+    """Reads a file with line numbers, raising errors on failure."""
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    if not file_path.is_file():
+        raise IsADirectoryError(f"Path is not a file: {file_path}")
+
+    try:
+        lines = file_path.read_text(encoding="utf-8").splitlines()
+    except Exception as e:
+        raise OSError(f"Error reading file {file_path}: {e}") from e
+
+    start = (offset - 1) if offset and offset > 0 else 0
+    end = (start + limit) if limit else len(lines)
+
+    result_lines = []
+    for i, line in enumerate(lines[start:end], start=start + 1):
+        if len(line) > 2000:
+            line = line[:2000] + "..."
+        result_lines.append(f"{i:6d}|{line}")
+
+    if not result_lines:
+        return "File is empty."
+
+    return "\n".join(result_lines)
+
+
+def write_file_content(file_path: Path, content: str) -> str:
+    """Writes content to a file, creating parent directories if needed."""
+    try:
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text(content, encoding="utf-8")
+        logger.info(f"Successfully wrote to {file_path}")
+        return f"Successfully wrote to {file_path}"
+    except Exception as e:
+        raise OSError(f"Error writing file {file_path}: {e}") from e
+
+
+def edit_file_content(
+    file_path: Path,
+    old_string: str,
+    new_string: str,
+    replace_all: bool = False,
+) -> str:
+    """Performs an exact string replacement in a file."""
+    if old_string == new_string:
+        raise ValueError("old_string and new_string must be different")
+
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    if not file_path.is_file():
+        raise IsADirectoryError(f"Path is not a file: {file_path}")
+
+    try:
+        content = file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        raise OSError(f"Error reading file {file_path}: {e}") from e
+
+    if old_string not in content:
+        raise ValueError(f"old_string not found in {file_path}")
+
+    count = content.count(old_string)
+    if not replace_all and count > 1:
+        raise ValueError(
+            f"old_string appears {count} times in {file_path}. Provide more context or set replace_all=true."
+        )
+
+    if replace_all:
+        new_content = content.replace(old_string, new_string)
+    else:
+        new_content = content.replace(old_string, new_string, 1)
+
+    try:
+        file_path.write_text(new_content, encoding="utf-8")
+        logger.info(f"Successfully replaced {count} occurrence(s) in {file_path}")
+        return f"Successfully replaced {count} occurrence(s) in {file_path}"
+    except Exception as e:
+        raise OSError(f"Error writing file {file_path}: {e}") from e
+
+
+# --- Shell Operation Tools ---
+
+
+def _get_command_timeout_seconds(command: str) -> float:
+    """Determine appropriate timeout for a command."""
+    if "python " in command or "python3 " in command:
+        return 60.0  # 1 minute for python scripts
+    else:
+        return 30.0  # 30 seconds for other commands
+
+
+async def execute_command(
+    command: str,
+    working_dir: Path,
+) -> str:
+    """Executes a shell command in a sandboxed environment."""
+    timeout = _get_command_timeout_seconds(command)
+
+    env = os.environ.copy()
+    # Add skills directory and working directory to PYTHONPATH
+    pythonpath_additions = [str(working_dir), "/skills"]
+    if "PYTHONPATH" in env:
+        pythonpath_additions.append(env["PYTHONPATH"])
+    env["PYTHONPATH"] = ":".join(pythonpath_additions)
+
+    # If a separate venv for shell commands is specified, use its python and pip
+    # Otherwise the system python/pip will be used for backward compatibility
+    bash_venv_path = os.environ.get("BASH_VENV_PATH")
+    if bash_venv_path:
+        bash_venv_bin = os.path.join(bash_venv_path, "bin")
+        # Prepend bash venv to PATH so its python and pip are used
+        env["PATH"] = f"{bash_venv_bin}:{env.get('PATH', '')}"
+        env["VIRTUAL_ENV"] = bash_venv_path
+
+    sandboxed_command = f'srt "{command}"'
+
+    try:
+        process = await asyncio.create_subprocess_shell(
+            sandboxed_command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=working_dir,
+            env=env,
+        )
+
+        try:
+            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
+        except TimeoutError:
+            process.kill()
+            await process.wait()
+            return f"Error: Command timed out after {timeout}s"
+
+        stdout_str = stdout.decode("utf-8", errors="replace") if stdout else ""
+        stderr_str = stderr.decode("utf-8", errors="replace") if stderr else ""
+
+        if process.returncode != 0:
+            error_msg = f"Command failed with exit code {process.returncode}"
+            if stderr_str:
+                error_msg += f":\n{stderr_str}"
+            elif stdout_str:
+                error_msg += f":\n{stdout_str}"
+            return error_msg
+
+        output = stdout_str
+        if stderr_str and "WARNING" not in stderr_str:
+            output += f"\n{stderr_str}"
+
+        logger.info(f"Command executed successfully: {output}")
+
+        return output.strip() if output.strip() else "Command completed successfully."
+
+    except Exception as e:
+        logger.error(f"Error executing command: {e}")
+        return f"Error: {e}"

kagent_skills-0.7.13/src/kagent/tests/unittests/test_skill_execution.py

@@ -0,0 +1,142 @@
+import json
+import shutil
+import tempfile
+import textwrap
+from pathlib import Path
+
+import pytest
+
+from kagent.skills import (
+    discover_skills,
+    execute_command,
+    load_skill_content,
+    read_file_content,
+)
+
+
+@pytest.fixture
+def skill_test_env() -> Path:
+    """
+    Creates a temporary environment that mimics a real session and ensures cleanup.
+
+    This fixture manually creates and deletes the temporary directory structure
+    to guarantee that no files are left behind after the test run.
+    """
+    # 1. Create a single top-level temporary directory
+    top_level_dir = Path(tempfile.mkdtemp())
+
+    try:
+        session_dir = top_level_dir / "session"
+        skills_root_dir = top_level_dir / "skills_root"
+
+        # 2. Create session directories
+        (session_dir / "uploads").mkdir(parents=True, exist_ok=True)
+        (session_dir / "outputs").mkdir(parents=True, exist_ok=True)
+
+        # 3. Create the skill to be tested
+        skill_dir = skills_root_dir / "csv-to-json"
+        script_dir = skill_dir / "scripts"
+        script_dir.mkdir(parents=True, exist_ok=True)
+
+        # SKILL.md
+        (skill_dir / "SKILL.md").write_text(
+            textwrap.dedent("""\
+---
+            name: csv-to-json
+            description: Converts a CSV file to a JSON file.
+            ---
+            # CSV to JSON Conversion
+            Use the `convert.py` script to convert a CSV file from the `uploads` directory
+            to a JSON file in the `outputs` directory.
+            Example: `bash("python skills/csv-to-json/scripts/convert.py uploads/data.csv outputs/result.json")`
+        """)
+        )
+
+        # Python script for the skill
+        (script_dir / "convert.py").write_text(
+            textwrap.dedent("""
+            import csv
+            import json
+            import sys
+            if len(sys.argv) != 3:
+                print(f"Usage: python {sys.argv[0]} <input_csv> <output_json>")
+                sys.exit(1)
+            input_path, output_path = sys.argv[1], sys.argv[2]
+            try:
+                data = []
+                with open(input_path, 'r', encoding='utf-8') as f:
+                    reader = csv.DictReader(f)
+                    for row in reader:
+                        data.append(row)
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    json.dump(data, f, indent=2)
+                print(f"Successfully converted {input_path} to {output_path}")
+            except FileNotFoundError:
+                print(f"Error: Input file not found at {input_path}")
+                sys.exit(1)
+        """)
+        )
+
+        # 4. Create a symlink from the session to the skills root
+        (session_dir / "skills").symlink_to(skills_root_dir, target_is_directory=True)
+
+        # 5. Yield the session directory path to the test
+        yield session_dir
+
+    finally:
+        # 6. Explicitly clean up the entire temporary directory
+        shutil.rmtree(top_level_dir)
+
+
+@pytest.mark.asyncio
+async def test_skill_core_logic(skill_test_env: Path):
+    """
+    Tests the core logic of the 'csv-to-json' skill by directly
+    calling the centralized tool functions.
+    """
+    session_dir = skill_test_env
+
+    # 1. "Upload" a file for the skill to process
+    input_csv_path = session_dir / "uploads" / "data.csv"
+    input_csv_path.write_text("id,name\n1,Alice\n2,Bob\n")
+
+    # 2. Execute the skill's core command, just as an agent would
+    # We use the centralized `execute_command` function directly
+    command = "python skills/csv-to-json/scripts/convert.py uploads/data.csv outputs/result.json"
+    result = await execute_command(command, working_dir=session_dir)
+
+    assert "Successfully converted" in result
+
+    # 3. Verify the output by reading the generated file
+    # We use the centralized `read_file_content` function directly
+    output_json_path = session_dir / "outputs" / "result.json"
+
+    # The read_file_content function returns a string with line numbers,
+    # so we need to parse it.
+    raw_output = read_file_content(output_json_path)
+    json_content_str = "\n".join(line.split("|", 1)[1] for line in raw_output.splitlines())
+
+    # Assert the content is correct
+    expected_data = [{"id": "1", "name": "Alice"}, {"id": "2", "name": "Bob"}]
+    assert json.loads(json_content_str) == expected_data
+
+
+def test_skill_discovery_and_loading(skill_test_env: Path):
+    """
+    Tests the core logic of discovering a skill and loading its instructions.
+    """
+    # The fixture creates the session dir, the skills are one level up in a separate dir
+    skills_root_dir = skill_test_env.parent / "skills_root"
+
+    # 1. Test skill discovery
+    discovered = discover_skills(skills_root_dir)
+    assert len(discovered) == 1
+    skill_meta = discovered[0]
+    assert skill_meta.name == "csv-to-json"
+    assert "Converts a CSV file" in skill_meta.description
+
+    # 2. Test skill content loading
+    skill_content = load_skill_content(skills_root_dir, "csv-to-json")
+    assert "name: csv-to-json" in skill_content
+    assert "# CSV to JSON Conversion" in skill_content
+    assert 'Example: `bash("python skills/csv-to-json/scripts/convert.py' in skill_content

kagent_skills-0.7.13/src/kagent_skills.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: kagent-skills
+Version: 0.7.13
+Summary: Core library for discovering and loading KAgent skills.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# KAgent Skills
+
+Core library for discovering, parsing, and loading KAgent skills from the filesystem.
+
+For example usage, see `kagent-adk` and `kagent-openai` packages.

kagent_skills-0.7.13/src/kagent_skills.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/kagent/skills/__init__.py
+src/kagent/skills/discovery.py
+src/kagent/skills/models.py
+src/kagent/skills/prompts.py
+src/kagent/skills/session.py
+src/kagent/skills/shell.py
+src/kagent/tests/unittests/test_skill_execution.py
+src/kagent_skills.egg-info/PKG-INFO
+src/kagent_skills.egg-info/SOURCES.txt
+src/kagent_skills.egg-info/dependency_links.txt
+src/kagent_skills.egg-info/requires.txt
+src/kagent_skills.egg-info/top_level.txt

kagent_skills-0.7.13/src/kagent_skills.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kagent_skills-0.7.13/src/kagent_skills.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pydantic>=2.0.0
+pyyaml>=6.0
+
+[dev]
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+black>=23.0.0
+ruff>=0.1.0

kagent_skills-0.7.13/src/kagent_skills.egg-info/top_level.txt

@@ -0,0 +1 @@
+kagent