agent-brain-cli 9.0.0__tar.gz → 9.2.0__tar.gz

{agent_brain_cli-9.0.0 → agent_brain_cli-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agent-brain-cli
-Version: 9.0.0
+Version: 9.2.0
 Summary: Agent Brain CLI - Command-line interface for managing AI agent memory and knowledge retrieval
 Home-page: https://github.com/SpillwaveSolutions/agent-brain
 License: MIT
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: agent-brain-rag (>=9.0.0,<10.0.0)
+Requires-Dist: agent-brain-rag (>=9.2.0,<10.0.0)
 Requires-Dist: click (>=8.1.0,<9.0.0)
 Requires-Dist: httpx (>=0.28.0,<0.29.0)
 Requires-Dist: pydantic (>=2.10.0,<3.0.0)

{agent_brain_cli-9.0.0 → agent_brain_cli-9.2.0}/agent_brain_cli/__init__.py

@@ -1,3 +1,3 @@
 """Doc-Serve CLI - Command-line interface for managing Doc-Serve server."""
 
-__version__ = "9.0.0"
+__version__ = "9.2.0"

{agent_brain_cli-9.0.0 → agent_brain_cli-9.2.0}/agent_brain_cli/commands/install_agent.py

@@ -2,15 +2,18 @@
 
 import json
 from pathlib import Path
+from typing import Any
 
 import click
 from rich.console import Console
 from rich.panel import Panel
 
 from agent_brain_cli.runtime.claude_converter import ClaudeConverter
+from agent_brain_cli.runtime.codex_converter import CodexConverter
 from agent_brain_cli.runtime.gemini_converter import GeminiConverter
 from agent_brain_cli.runtime.opencode_converter import OpenCodeConverter
 from agent_brain_cli.runtime.parser import parse_plugin_dir
+from agent_brain_cli.runtime.skill_runtime_converter import SkillRuntimeConverter
 from agent_brain_cli.runtime.types import Scope
 
 console = Console()
@@ -29,12 +32,29 @@ INSTALL_DIRS: dict[str, dict[str, str]] = {
         "project": ".gemini/plugins/agent-brain",
         "global": "~/.config/gemini/plugins/agent-brain",
     },
+    "codex": {
+        "project": ".codex/skills/agent-brain",
+        "global": "~/.codex/skills/agent-brain",
+    },
 }
 
-CONVERTERS: dict[str, type[ClaudeConverter | OpenCodeConverter | GeminiConverter]] = {
+# Runtimes that require --dir (no default directory)
+DIR_REQUIRED_RUNTIMES = {"skill-runtime"}
+
+ConverterType = type[
+    ClaudeConverter
+    | OpenCodeConverter
+    | GeminiConverter
+    | SkillRuntimeConverter
+    | CodexConverter
+]
+
+CONVERTERS: dict[str, ConverterType] = {
     "claude": ClaudeConverter,
     "opencode": OpenCodeConverter,
     "gemini": GeminiConverter,
+    "skill-runtime": SkillRuntimeConverter,
+    "codex": CodexConverter,
 }
 
 
@@ -58,9 +78,14 @@ def _find_plugin_dir() -> Path | None:
 
 
 def _resolve_target_dir(
-    runtime: str, scope: str, project_root: Path | None = None
+    runtime: str,
+    scope: str,
+    project_root: Path | None = None,
+    custom_dir: str | None = None,
 ) -> Path:
     """Resolve the target installation directory."""
+    if custom_dir:
+        return Path(custom_dir).expanduser().resolve()
     dir_template = INSTALL_DIRS[runtime][scope]
     if scope == "global":
         return Path(dir_template).expanduser()
@@ -69,12 +94,15 @@ def _resolve_target_dir(
     return project_root / dir_template
 
 
+RUNTIME_CHOICES = ["claude", "opencode", "gemini", "skill-runtime", "codex"]
+
+
 @click.command("install-agent")
 @click.option(
     "--agent",
     "-a",
     required=True,
-    type=click.Choice(["claude", "opencode", "gemini"]),
+    type=click.Choice(RUNTIME_CHOICES),
     help="Target runtime to install for",
 )
 @click.option(
@@ -95,6 +123,12 @@ def _resolve_target_dir(
     type=click.Path(exists=True, file_okay=False, resolve_path=True),
     help="Custom canonical plugin source directory",
 )
+@click.option(
+    "--dir",
+    "target_dir_option",
+    type=click.Path(resolve_path=True),
+    help="Target skill directory (required for skill-runtime)",
+)
 @click.option(
     "--dry-run",
     is_flag=True,
@@ -116,6 +150,7 @@ def install_agent_command(
     agent: str,
     scope: str,
     plugin_dir: str | None,
+    target_dir_option: str | None,
     dry_run: bool,
     json_output: bool,
     path: str | None,
@@ -130,9 +165,22 @@ def install_agent_command(
       agent-brain install-agent --agent claude --project
       agent-brain install-agent --agent opencode --global
       agent-brain install-agent --agent gemini --dry-run
-      agent-brain install-agent --agent claude --plugin-dir ./my-plugin
+      agent-brain install-agent --agent skill-runtime --dir ./my-skills
+      agent-brain install-agent --agent codex
     """
     try:
+        # Validate --dir requirement for skill-runtime
+        if agent in DIR_REQUIRED_RUNTIMES and not target_dir_option:
+            msg = (
+                f"--dir is required for --agent {agent}. "
+                "Specify the target skill directory."
+            )
+            if json_output:
+                click.echo(json.dumps({"error": msg}))
+            else:
+                console.print(f"[red]Error:[/] {msg}")
+            raise SystemExit(1)
+
         # Resolve plugin source directory
         source: Path
         if plugin_dir:
@@ -158,12 +206,14 @@ def install_agent_command(
             console.print(
                 f"[dim]Parsed {len(bundle.commands)} commands, "
                 f"{len(bundle.agents)} agents, "
-                f"{len(bundle.skills)} skills[/]"
+                f"{len(bundle.skills)} skills, "
+                f"{len(bundle.templates)} templates, "
+                f"{len(bundle.scripts)} scripts[/]"
             )
 
         # Resolve target directory
         project_root = Path(path) if path else None
-        target = _resolve_target_dir(agent, scope, project_root)
+        target = _resolve_target_dir(agent, scope, project_root, target_dir_option)
 
         # Create converter
         converter_cls = CONVERTERS[agent]
@@ -171,62 +221,36 @@ def install_agent_command(
         scope_enum = Scope.GLOBAL if scope == "global" else Scope.PROJECT
 
         if dry_run:
-            # Simulate install without writing
-            import tempfile
-
-            with tempfile.TemporaryDirectory() as tmp:
-                tmp_target = Path(tmp)
-                files = converter.install(bundle, tmp_target, scope_enum)
-                # Remap paths to real target
-                planned = [target / f.relative_to(tmp_target) for f in files]
-
-            if json_output:
-                click.echo(
-                    json.dumps(
-                        {
-                            "dry_run": True,
-                            "agent": agent,
-                            "scope": scope,
-                            "target_dir": str(target),
-                            "files": [str(f) for f in planned],
-                            "file_count": len(planned),
-                        },
-                        indent=2,
-                    )
-                )
-            else:
-                console.print(
-                    Panel(
-                        f"[yellow]Dry run[/] — no files written\n\n"
-                        f"[bold]Runtime:[/] {agent}\n"
-                        f"[bold]Scope:[/] {scope}\n"
-                        f"[bold]Target:[/] {target}\n"
-                        f"[bold]Files:[/] {len(planned)}",
-                        title="Install Preview",
-                        border_style="yellow",
-                    )
-                )
-                for f in planned:
-                    console.print(f"  [dim]{f}[/]")
+            _handle_dry_run(
+                converter,
+                bundle,
+                target,
+                scope_enum,
+                agent,
+                scope,
+                json_output,
+            )
             return
 
         # Actually install
-        files = converter.install(bundle, target, scope_enum)
+        if isinstance(converter, CodexConverter):
+            codex_root = Path(path) if path else Path.cwd()
+            files = converter.install(
+                bundle, target, scope_enum, project_root=codex_root
+            )
+        else:
+            files = converter.install(bundle, target, scope_enum)
 
         if json_output:
-            click.echo(
-                json.dumps(
-                    {
-                        "status": "installed",
-                        "agent": agent,
-                        "scope": scope,
-                        "target_dir": str(target),
-                        "files_created": len(files),
-                        "source_dir": str(source),
-                    },
-                    indent=2,
-                )
-            )
+            result: dict[str, Any] = {
+                "status": "installed",
+                "agent": agent,
+                "scope": scope,
+                "target_dir": str(target),
+                "files_created": len(files),
+                "source_dir": str(source),
+            }
+            click.echo(json.dumps(result, indent=2))
         else:
             console.print(
                 Panel(
@@ -248,3 +272,69 @@ def install_agent_command(
         else:
             console.print(f"[red]Error:[/] {exc}")
         raise SystemExit(1) from exc
+
+
+def _handle_dry_run(
+    converter: (
+        ClaudeConverter
+        | OpenCodeConverter
+        | GeminiConverter
+        | SkillRuntimeConverter
+        | CodexConverter
+    ),
+    bundle: Any,
+    target: Path,
+    scope_enum: Scope,
+    agent: str,
+    scope: str,
+    json_output: bool,
+) -> None:
+    """Handle dry-run mode: simulate install in temp dir."""
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_target = Path(tmp)
+        # For Codex, pass tmp as project_root so AGENTS.md lands in tmpdir
+        if isinstance(converter, CodexConverter):
+            files = converter.install(
+                bundle, tmp_target, scope_enum, project_root=Path(tmp)
+            )
+        else:
+            files = converter.install(bundle, tmp_target, scope_enum)
+        # Remap paths to real target
+        planned: list[Path] = []
+        for f in files:
+            try:
+                planned.append(target / f.relative_to(tmp_target))
+            except ValueError:
+                # AGENTS.md may be at project_root, not under target
+                planned.append(f)
+
+    if json_output:
+        click.echo(
+            json.dumps(
+                {
+                    "dry_run": True,
+                    "agent": agent,
+                    "scope": scope,
+                    "target_dir": str(target),
+                    "files": [str(f) for f in planned],
+                    "file_count": len(planned),
+                },
+                indent=2,
+            )
+        )
+    else:
+        console.print(
+            Panel(
+                f"[yellow]Dry run[/] — no files written\n\n"
+                f"[bold]Runtime:[/] {agent}\n"
+                f"[bold]Scope:[/] {scope}\n"
+                f"[bold]Target:[/] {target}\n"
+                f"[bold]Files:[/] {len(planned)}",
+                title="Install Preview",
+                border_style="yellow",
+            )
+        )
+        for f in planned:
+            console.print(f"  [dim]{f}[/]")

{agent_brain_cli-9.0.0 → agent_brain_cli-9.2.0}/agent_brain_cli/runtime/__init__.py

@@ -6,7 +6,9 @@ from agent_brain_cli.runtime.parser import (
     parse_command,
     parse_frontmatter,
     parse_plugin_dir,
+    parse_scripts,
     parse_skill,
+    parse_templates,
 )
 from agent_brain_cli.runtime.tool_maps import (
     CLAUDE_TOOLS,
@@ -21,7 +23,9 @@ from agent_brain_cli.runtime.types import (
     PluginCommand,
     PluginManifest,
     PluginParameter,
+    PluginScript,
     PluginSkill,
+    PluginTemplate,
     RuntimeType,
     Scope,
     TriggerPattern,
@@ -36,7 +40,9 @@ __all__ = [
     "PluginCommand",
     "PluginManifest",
     "PluginParameter",
+    "PluginScript",
     "PluginSkill",
+    "PluginTemplate",
     "RuntimeConverter",
     "RuntimeType",
     "Scope",
@@ -47,5 +53,7 @@ __all__ = [
     "parse_command",
     "parse_frontmatter",
     "parse_plugin_dir",
+    "parse_scripts",
     "parse_skill",
+    "parse_templates",
 ]

agent_brain_cli-9.2.0/agent_brain_cli/runtime/codex_converter.py

@@ -0,0 +1,215 @@
+"""Codex runtime converter.
+
+Codex is a named preset built on the generic skill-runtime converter.
+It installs to `.codex/skills/agent-brain/` and generates an AGENTS.md
+file at the project root with Agent Brain guidance.
+
+Key differences from base SkillRuntimeConverter:
+    - Default install dir: .codex/skills/agent-brain/
+    - AGENTS.md generated at project root (idempotent via HTML comment markers)
+    - Skills include invocation guidance headers
+"""
+
+import logging
+from pathlib import Path
+
+from agent_brain_cli.runtime.skill_runtime_converter import (
+    SkillRuntimeConverter,
+)
+from agent_brain_cli.runtime.types import (
+    PluginAgent,
+    PluginBundle,
+    PluginCommand,
+    PluginSkill,
+    RuntimeType,
+    Scope,
+)
+
+logger = logging.getLogger(__name__)
+
+# HTML comment markers for idempotent AGENTS.md updates
+AGENTS_MD_START = "<!-- agent-brain:start -->"
+AGENTS_MD_END = "<!-- agent-brain:end -->"
+
+AGENTS_MD_SECTION = """\
+{start_marker}
+
+## Agent Brain
+
+Agent Brain provides semantic search over your codebase and documentation.
+
+### Available Skills
+
+| Skill | Description |
+|-------|-------------|
+{skill_table}
+
+### Usage
+
+Ask your AI assistant to search documentation or code:
+
+- "Search for authentication patterns in my codebase"
+- "Find documentation about the API endpoints"
+- "Look up how error handling works"
+
+### Setup
+
+Run `agent-brain start` to start the Agent Brain server, then use
+`agent-brain index ./src` to index your source code.
+
+{end_marker}"""
+
+
+class CodexConverter:
+    """Converter for Codex runtime (skill-runtime preset).
+
+    Delegates skill-directory creation to SkillRuntimeConverter and
+    adds Codex-specific AGENTS.md generation.
+    """
+
+    def __init__(self) -> None:
+        self._base = SkillRuntimeConverter()
+
+    @property
+    def runtime_type(self) -> RuntimeType:
+        return RuntimeType.CODEX
+
+    def convert_command(self, command: PluginCommand) -> str:
+        """Convert command with Codex invocation guidance header."""
+        base_content = self._base.convert_command(command)
+        return _add_codex_header(base_content, command.name)
+
+    def convert_agent(self, agent: PluginAgent) -> str:
+        """Convert agent with Codex invocation guidance header."""
+        base_content = self._base.convert_agent(agent)
+        return _add_codex_header(base_content, agent.name)
+
+    def convert_skill(self, skill: PluginSkill) -> str:
+        """Convert skill with Codex invocation guidance header."""
+        return self._base.convert_skill(skill)
+
+    def install(
+        self,
+        bundle: PluginBundle,
+        target_dir: Path,
+        scope: Scope,
+        project_root: Path | None = None,
+    ) -> list[Path]:
+        """Install Codex skills and generate AGENTS.md.
+
+        Delegates skill-directory creation to the base converter,
+        then generates/updates AGENTS.md at the project root.
+
+        Args:
+            bundle: Parsed plugin bundle.
+            target_dir: Where to write skill directories.
+            scope: Project-level or global installation.
+            project_root: Project root for AGENTS.md. If None,
+                derived from target_dir for project scope.
+        """
+        # Install skill directories via base converter
+        created = self._base.install(bundle, target_dir, scope)
+
+        # Re-write command and agent SKILL.md files with Codex headers
+        for cmd in bundle.commands:
+            from agent_brain_cli.runtime.skill_runtime_converter import (
+                _skill_dir_name,
+            )
+
+            skill_name = _skill_dir_name(cmd.name)
+            skill_file = target_dir / skill_name / "SKILL.md"
+            if skill_file.exists():
+                skill_file.write_text(self.convert_command(cmd), encoding="utf-8")
+
+        for agent in bundle.agents:
+            from agent_brain_cli.runtime.skill_runtime_converter import (
+                _skill_dir_name,
+            )
+
+            skill_name = _skill_dir_name(agent.name)
+            skill_file = target_dir / skill_name / "SKILL.md"
+            if skill_file.exists():
+                skill_file.write_text(self.convert_agent(agent), encoding="utf-8")
+
+        # Generate AGENTS.md at project root
+        if project_root is None:
+            if scope == Scope.PROJECT:
+                # .codex/skills/agent-brain → project root (3 levels up)
+                project_root = target_dir.parent.parent.parent
+            else:
+                project_root = Path.cwd()
+
+        agents_md_path = project_root / "AGENTS.md"
+        try:
+            agents_md_files = _update_agents_md(agents_md_path, bundle)
+            created.extend(agents_md_files)
+        except OSError as exc:
+            logger.warning("Could not write AGENTS.md: %s", exc)
+
+        return created
+
+
+def _add_codex_header(content: str, name: str) -> str:
+    """Add a Codex invocation guidance header after the frontmatter.
+
+    Inserts a brief note about how to invoke this skill in Codex.
+    """
+    # Split on the closing --- of frontmatter
+    parts = content.split("---\n", 2)
+    if len(parts) < 3:
+        return content
+
+    header = (
+        f"> **Codex Skill:** `{name}`\n"
+        f"> Invoke by asking about {name} or referencing it directly.\n\n"
+    )
+    return f"---\n{parts[1]}---\n{header}{parts[2]}"
+
+
+def _update_agents_md(agents_md_path: Path, bundle: PluginBundle) -> list[Path]:
+    """Generate or update AGENTS.md with Agent Brain section.
+
+    Uses HTML comment markers for idempotent updates — running this
+    multiple times will replace the existing section rather than
+    duplicating it.
+
+    Returns list of created/updated paths.
+    """
+    # Build skill table
+    skill_rows: list[str] = []
+    for cmd in bundle.commands:
+        skill_rows.append(f"| {cmd.name} | {cmd.description} |")
+    for agent in bundle.agents:
+        skill_rows.append(f"| {agent.name} | {agent.description} |")
+    for skill in bundle.skills:
+        skill_rows.append(f"| {skill.name} | {skill.description} |")
+
+    skill_table = "\n".join(skill_rows) if skill_rows else "| (none) | - |"
+
+    section = AGENTS_MD_SECTION.format(
+        start_marker=AGENTS_MD_START,
+        end_marker=AGENTS_MD_END,
+        skill_table=skill_table,
+    )
+
+    if agents_md_path.exists():
+        existing = agents_md_path.read_text(encoding="utf-8")
+        if AGENTS_MD_START in existing and AGENTS_MD_END in existing:
+            # Replace existing section
+            start_idx = existing.index(AGENTS_MD_START)
+            end_idx = existing.index(AGENTS_MD_END) + len(AGENTS_MD_END)
+            updated = existing[:start_idx] + section + existing[end_idx:]
+            agents_md_path.write_text(updated, encoding="utf-8")
+        else:
+            # Append section
+            agents_md_path.write_text(
+                existing.rstrip() + "\n\n" + section + "\n",
+                encoding="utf-8",
+            )
+    else:
+        # Create new file
+        content = f"# AGENTS.md\n\n{section}\n"
+        agents_md_path.parent.mkdir(parents=True, exist_ok=True)
+        agents_md_path.write_text(content, encoding="utf-8")
+
+    return [agents_md_path]

{agent_brain_cli-9.0.0 → agent_brain_cli-9.2.0}/agent_brain_cli/runtime/parser.py

@@ -13,7 +13,9 @@ from agent_brain_cli.runtime.types import (
     PluginCommand,
     PluginManifest,
     PluginParameter,
+    PluginScript,
     PluginSkill,
+    PluginTemplate,
     TriggerPattern,
 )
 
@@ -195,6 +197,62 @@ def parse_manifest(path: Path) -> PluginManifest:
     )
 
 
+def parse_templates(templates_dir: Path) -> list[PluginTemplate]:
+    """Parse template files from the templates/ directory.
+
+    Args:
+        templates_dir: Path to the templates directory.
+
+    Returns:
+        List of parsed PluginTemplate objects.
+    """
+    templates: list[PluginTemplate] = []
+    if not templates_dir.is_dir():
+        return templates
+    for tpl_file in sorted(templates_dir.iterdir()):
+        if tpl_file.is_file():
+            try:
+                content = tpl_file.read_text(encoding="utf-8")
+                templates.append(
+                    PluginTemplate(
+                        name=tpl_file.name,
+                        content=content,
+                        source_path=str(tpl_file),
+                    )
+                )
+            except OSError as exc:
+                logger.warning("Failed to read template %s: %s", tpl_file, exc)
+    return templates
+
+
+def parse_scripts(scripts_dir: Path) -> list[PluginScript]:
+    """Parse script files from the scripts/ directory.
+
+    Args:
+        scripts_dir: Path to the scripts directory.
+
+    Returns:
+        List of parsed PluginScript objects.
+    """
+    scripts: list[PluginScript] = []
+    if not scripts_dir.is_dir():
+        return scripts
+    for script_file in sorted(scripts_dir.iterdir()):
+        if script_file.is_file():
+            try:
+                content = script_file.read_text(encoding="utf-8")
+                scripts.append(
+                    PluginScript(
+                        name=script_file.name,
+                        content=content,
+                        source_path=str(script_file),
+                    )
+                )
+            except OSError as exc:
+                logger.warning("Failed to read script %s: %s", script_file, exc)
+    return scripts
+
+
 def parse_plugin_dir(plugin_dir: Path) -> PluginBundle:
     """Parse an entire plugin directory into a PluginBundle.
 
@@ -255,10 +313,18 @@ def parse_plugin_dir(plugin_dir: Path) -> PluginBundle:
                 except (ValueError, OSError) as exc:
                     logger.warning("Failed to parse skill %s: %s", skill_file, exc)
 
+    # Parse templates
+    templates = parse_templates(plugin_dir / "templates")
+
+    # Parse scripts
+    scripts = parse_scripts(plugin_dir / "scripts")
+
     return PluginBundle(
         commands=commands,
         agents=agents,
         skills=skills,
+        templates=templates,
+        scripts=scripts,
         manifest=manifest,
         source_dir=str(plugin_dir),
     )

agent_brain_cli-9.2.0/agent_brain_cli/runtime/skill_runtime_converter.py

@@ -0,0 +1,234 @@
+"""Generic skill-runtime converter.
+
+Transforms all plugin artifacts (commands, agents, skills, templates, scripts)
+into flat skill directories. Each artifact becomes a directory with a SKILL.md
+file. This converter supports any runtime that uses skill directories (Codex,
+Qwen, Cursor, etc.) via the --dir option.
+
+Transformation rules:
+    command agent-brain-init.md  → <dir>/agent-brain-init/SKILL.md
+    agent research-assistant.md  → <dir>/agent-brain-research/SKILL.md
+    skill using-agent-brain/     → <dir>/agent-brain-using/SKILL.md + references/
+    templates/*                  → <dir>/agent-brain-setup/assets/
+    scripts/*                    → <dir>/agent-brain-verify/scripts/
+"""
+
+import logging
+import shutil
+from pathlib import Path
+
+import yaml
+
+from agent_brain_cli.runtime.types import (
+    PluginAgent,
+    PluginBundle,
+    PluginCommand,
+    PluginSkill,
+    RuntimeType,
+    Scope,
+)
+
+logger = logging.getLogger(__name__)
+
+LEGACY_PATH = ".claude/agent-brain"
+NEW_PATH = ".agent-brain"
+
+
+def _replace_paths(text: str) -> str:
+    """Replace legacy state dir paths with new runtime-neutral paths."""
+    return text.replace(LEGACY_PATH, NEW_PATH)
+
+
+def _build_skill_md(frontmatter: dict, body: str) -> str:  # type: ignore[type-arg]
+    """Build a SKILL.md file from frontmatter and body."""
+    yaml_str = yaml.dump(frontmatter, default_flow_style=False, sort_keys=False)
+    return f"---\n{yaml_str}---\n{body}\n"
+
+
+def _skill_dir_name(name: str, prefix: str = "agent-brain-") -> str:
+    """Derive a skill directory name from an artifact name.
+
+    Ensures the name starts with the agent-brain- prefix for namespacing.
+    """
+    if name.startswith(prefix):
+        return name
+    return f"{prefix}{name}"
+
+
+class SkillRuntimeConverter:
+    """Converter that flattens all plugin artifacts into skill directories.
+
+    Commands become skills with their body as instructions.
+    Agents become orchestration skills referencing dependent skills.
+    Existing skills are copied with references intact.
+    Templates and scripts become asset skill directories.
+    """
+
+    @property
+    def runtime_type(self) -> RuntimeType:
+        return RuntimeType.SKILL_RUNTIME
+
+    def convert_command(self, command: PluginCommand) -> str:
+        """Convert a command into a SKILL.md file.
+
+        The command body becomes the skill instructions, with
+        allowed-tools set to common tools needed for CLI commands.
+        """
+        fm: dict[str, object] = {
+            "name": command.name,
+            "description": command.description,
+            "allowed-tools": ["Bash", "Read", "Write"],
+        }
+        if command.parameters:
+            params_text = "\n\n## Parameters\n\n"
+            for p in command.parameters:
+                req = " (required)" if p.required else ""
+                default = f" [default: {p.default}]" if p.default else ""
+                params_text += f"- **{p.name}**: {p.description}{req}{default}\n"
+            body = _replace_paths(command.body) + params_text
+        else:
+            body = _replace_paths(command.body)
+        return _build_skill_md(fm, body)
+
+    def convert_agent(self, agent: PluginAgent) -> str:
+        """Convert an agent into an orchestration SKILL.md file.
+
+        The agent body becomes skill instructions with a note that
+        this is an orchestration skill.
+        """
+        fm: dict[str, object] = {
+            "name": agent.name,
+            "description": agent.description,
+            "allowed-tools": ["Bash", "Read", "Write", "Grep", "Glob"],
+        }
+        header = "<!-- Orchestration skill converted from agent -->\n\n"
+        if agent.skills:
+            header += "## Related Skills\n\n"
+            for skill_name in agent.skills:
+                header += f"- {skill_name}\n"
+            header += "\n"
+        body = header + _replace_paths(agent.body)
+        return _build_skill_md(fm, body)
+
+    def convert_skill(self, skill: PluginSkill) -> str:
+        """Convert a skill, preserving its existing format."""
+        fm: dict[str, object] = {
+            "name": skill.name,
+            "description": skill.description,
+            "allowed-tools": skill.allowed_tools,
+        }
+        if skill.license:
+            fm["license"] = skill.license
+        if skill.metadata:
+            fm["metadata"] = skill.metadata
+        return _build_skill_md(fm, _replace_paths(skill.body))
+
+    def install(
+        self,
+        bundle: PluginBundle,
+        target_dir: Path,
+        scope: Scope,
+    ) -> list[Path]:
+        """Install all plugin artifacts as flat skill directories.
+
+        Each artifact gets its own directory under target_dir with a
+        SKILL.md file. References, templates, and scripts are included
+        as assets.
+        """
+        created: list[Path] = []
+
+        # Commands → skill directories
+        for cmd in bundle.commands:
+            skill_name = _skill_dir_name(cmd.name)
+            skill_dir = target_dir / skill_name
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            skill_file = skill_dir / "SKILL.md"
+            skill_file.write_text(self.convert_command(cmd), encoding="utf-8")
+            created.append(skill_file)
+
+        # Agents → orchestration skill directories
+        for agent in bundle.agents:
+            skill_name = _skill_dir_name(agent.name)
+            skill_dir = target_dir / skill_name
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            skill_file = skill_dir / "SKILL.md"
+            skill_file.write_text(self.convert_agent(agent), encoding="utf-8")
+            created.append(skill_file)
+
+        # Skills → skill directories (with references)
+        for skill in bundle.skills:
+            skill_name = _skill_dir_name(skill.name)
+            skill_dir = target_dir / skill_name
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            skill_file = skill_dir / "SKILL.md"
+            skill_file.write_text(self.convert_skill(skill), encoding="utf-8")
+            created.append(skill_file)
+
+            # Copy references if they exist
+            if skill.source_path:
+                refs_src = Path(skill.source_path).parent / "references"
+                if refs_src.is_dir():
+                    refs_dest = skill_dir / "references"
+                    if refs_dest.exists():
+                        shutil.rmtree(refs_dest)
+                    shutil.copytree(refs_src, refs_dest)
+                    for ref in refs_dest.rglob("*"):
+                        if ref.is_file():
+                            created.append(ref)
+
+        # Templates → agent-brain-setup/assets/
+        if bundle.templates:
+            setup_dir = target_dir / "agent-brain-setup"
+            assets_dir = setup_dir / "assets"
+            assets_dir.mkdir(parents=True, exist_ok=True)
+            # Create a setup SKILL.md if it doesn't exist
+            setup_skill = setup_dir / "SKILL.md"
+            if not setup_skill.exists():
+                fm: dict[str, object] = {
+                    "name": "agent-brain-setup",
+                    "description": "Agent Brain setup templates and configuration",
+                    "allowed-tools": ["Bash", "Read", "Write"],
+                }
+                body = (
+                    "This skill contains setup templates for Agent Brain.\n\n"
+                    "## Assets\n\n"
+                )
+                for tpl in bundle.templates:
+                    body += f"- `assets/{tpl.name}`\n"
+                setup_skill.write_text(_build_skill_md(fm, body), encoding="utf-8")
+                created.append(setup_skill)
+
+            for tpl in bundle.templates:
+                tpl_file = assets_dir / tpl.name
+                tpl_file.write_text(tpl.content, encoding="utf-8")
+                created.append(tpl_file)
+
+        # Scripts → agent-brain-verify/scripts/
+        if bundle.scripts:
+            verify_dir = target_dir / "agent-brain-verify"
+            scripts_dir = verify_dir / "scripts"
+            scripts_dir.mkdir(parents=True, exist_ok=True)
+            # Create a verify SKILL.md if it doesn't exist
+            verify_skill = verify_dir / "SKILL.md"
+            if not verify_skill.exists():
+                fm_v: dict[str, object] = {
+                    "name": "agent-brain-verify",
+                    "description": "Agent Brain verification and health check scripts",
+                    "allowed-tools": ["Bash", "Read"],
+                }
+                body_v = (
+                    "This skill contains verification scripts for "
+                    "Agent Brain.\n\n"
+                    "## Scripts\n\n"
+                )
+                for script in bundle.scripts:
+                    body_v += f"- `scripts/{script.name}`\n"
+                verify_skill.write_text(_build_skill_md(fm_v, body_v), encoding="utf-8")
+                created.append(verify_skill)
+
+            for script in bundle.scripts:
+                script_file = scripts_dir / script.name
+                script_file.write_text(script.content, encoding="utf-8")
+                created.append(script_file)
+
+        return created

{agent_brain_cli-9.0.0 → agent_brain_cli-9.2.0}/agent_brain_cli/runtime/types.py

@@ -10,6 +10,8 @@ class RuntimeType(str, Enum):
     CLAUDE = "claude"
     OPENCODE = "opencode"
     GEMINI = "gemini"
+    SKILL_RUNTIME = "skill-runtime"
+    CODEX = "codex"
 
 
 class Scope(str, Enum):
@@ -75,6 +77,24 @@ class PluginSkill:
     references: list[str] = field(default_factory=list)
 
 
+@dataclass
+class PluginTemplate:
+    """A template file from the plugin templates/ directory."""
+
+    name: str
+    content: str
+    source_path: str = ""
+
+
+@dataclass
+class PluginScript:
+    """A script file from the plugin scripts/ directory."""
+
+    name: str
+    content: str
+    source_path: str = ""
+
+
 @dataclass
 class PluginManifest:
     """Parsed plugin.json manifest."""
@@ -96,5 +116,7 @@ class PluginBundle:
     commands: list[PluginCommand] = field(default_factory=list)
     agents: list[PluginAgent] = field(default_factory=list)
     skills: list[PluginSkill] = field(default_factory=list)
+    templates: list[PluginTemplate] = field(default_factory=list)
+    scripts: list[PluginScript] = field(default_factory=list)
     manifest: PluginManifest = field(default_factory=PluginManifest)
     source_dir: str = ""

{agent_brain_cli-9.0.0 → agent_brain_cli-9.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agent-brain-cli"
-version = "9.0.0"
+version = "9.2.0"
 description = "Agent Brain CLI - Command-line interface for managing AI agent memory and knowledge retrieval"
 authors = ["Spillwave Solutions"]
 readme = "README.md"
@@ -27,7 +27,7 @@ httpx = "^0.28.0"
 rich = "^13.9.0"
 pyyaml = "^6.0.0"
 pydantic = "^2.10.0"
-agent-brain-rag = "^9.0.0"
+agent-brain-rag = "^9.2.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.0"