aop-launcher 0.0.1.dev0__py3-none-any.whl

aop_launcher/__init__.py

@@ -0,0 +1,5 @@
+from aop_launcher.core import Agent, Workflow, WorkflowError, load_workflow, run_workflow
+
+__all__ = ["Agent", "Workflow", "WorkflowError", "load_workflow", "run_workflow"]
+__version__ = "0.0.1.dev0"
+

aop_launcher/cli.py

@@ -0,0 +1,48 @@
+import argparse
+import sys
+
+from aop_launcher.core import WorkflowError, load_workflow, run_workflow
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="aop-launcher",
+        description="Run a local YAML agent workflow.",
+    )
+    parser.add_argument("workflow", help="Path to the YAML workflow file.")
+    parser.add_argument("input", nargs="?", default="", help="Initial workflow input.")
+    parser.add_argument(
+        "--llm-command",
+        help="Local LLM command. Overrides llm.command in the workflow file.",
+    )
+    parser.add_argument(
+        "--no-tools",
+        action="store_true",
+        help="Skip workflow tool commands.",
+    )
+    return parser
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        workflow = load_workflow(args.workflow)
+        result = run_workflow(
+            workflow,
+            args.input,
+            llm_command=args.llm_command,
+            run_tools=not args.no_tools,
+            stream=sys.stdout,
+        )
+    except WorkflowError as exc:
+        print(f"aop-launcher: {exc}", file=sys.stderr)
+        return 2
+
+    return 0 if result else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

aop_launcher/core.py

@@ -0,0 +1,180 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+
+import yaml
+
+
+class WorkflowError(Exception):
+    """Raised when a workflow cannot be loaded or executed."""
+
+
+@dataclass(frozen=True)
+class Agent:
+    name: str
+    prompt: str
+    tools: tuple = field(default_factory=tuple)
+
+
+@dataclass(frozen=True)
+class Workflow:
+    agents: tuple
+    tools: dict = field(default_factory=dict)
+    llm_command: str = ""
+
+
+def load_workflow(path):
+    data = _load_yaml(path)
+    agents = tuple(_parse_agent(item) for item in data.get("agents", []))
+    if not agents:
+        raise WorkflowError("workflow must define at least one agent")
+
+    llm_data = data.get("llm") or {}
+    if llm_data and not isinstance(llm_data, dict):
+        raise WorkflowError("llm must be a mapping")
+
+    tools = data.get("tools") or {}
+    if not isinstance(tools, dict):
+        raise WorkflowError("tools must be a mapping of name to command")
+
+    return Workflow(
+        agents=agents,
+        tools={str(name): str(command) for name, command in tools.items()},
+        llm_command=str(llm_data.get("command", "")),
+    )
+
+
+def run_workflow(
+    workflow,
+    initial_input="",
+    *,
+    llm_command=None,
+    run_tools=True,
+    stream=None,
+):
+    output = str(initial_input)
+    terminal = stream or sys.stdout
+    command = llm_command or workflow.llm_command
+    if not command:
+        raise WorkflowError("missing local LLM command")
+
+    for agent in workflow.agents:
+        print(f"\n== {agent.name} ==", file=terminal)
+        tool_results = _run_tools(agent, workflow.tools, enabled=run_tools)
+        prompt = _render_prompt(agent.prompt, output, tool_results)
+        output = _run_llm(command, prompt, terminal)
+
+    return output
+
+
+def _load_yaml(path):
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            data = yaml.safe_load(handle) or {}
+    except OSError as exc:
+        raise WorkflowError(f"cannot read workflow: {exc}") from exc
+    except yaml.YAMLError as exc:
+        raise WorkflowError(f"invalid YAML: {exc}") from exc
+
+    if not isinstance(data, dict):
+        raise WorkflowError("workflow must be a YAML mapping")
+    return data
+
+
+def _parse_agent(item):
+    if not isinstance(item, dict):
+        raise WorkflowError("each agent must be a mapping")
+
+    name = str(item.get("name", "")).strip()
+    prompt = str(item.get("prompt", "")).strip()
+    if not name:
+        raise WorkflowError("agent is missing a name")
+    if not prompt:
+        raise WorkflowError(f"agent {name!r} is missing a prompt")
+
+    tools = item.get("tools") or ()
+    if isinstance(tools, str):
+        tools = (tools,)
+    elif isinstance(tools, (list, tuple)):
+        tools = tuple(str(tool) for tool in tools)
+    else:
+        raise WorkflowError(f"agent {name!r} tools must be a string or list")
+
+    return Agent(name=name, prompt=prompt, tools=tools)
+
+
+def _run_tools(agent, tools, *, enabled):
+    if not enabled:
+        return {}
+
+    results = {}
+    for name in agent.tools:
+        if name not in tools:
+            raise WorkflowError(f"agent {agent.name!r} references unknown tool {name!r}")
+        command = tools[name]
+        completed = subprocess.run(
+            command,
+            shell=True,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        results[name] = {
+            "returncode": completed.returncode,
+            "stdout": completed.stdout.strip(),
+            "stderr": completed.stderr.strip(),
+        }
+    return results
+
+
+def _render_prompt(template, input_text, tool_results):
+    return template.format(
+        input=input_text,
+        tool_results=_format_tool_results(tool_results),
+    )
+
+
+def _format_tool_results(tool_results):
+    if not tool_results:
+        return ""
+
+    lines = []
+    for name, result in tool_results.items():
+        lines.append(f"[{name}] returncode={result['returncode']}")
+        if result["stdout"]:
+            lines.append(result["stdout"])
+        if result["stderr"]:
+            lines.append(f"stderr: {result['stderr']}")
+    return "\n".join(lines)
+
+
+def _run_llm(command, prompt, stream):
+    args = shlex.split(command)
+    if not args:
+        raise WorkflowError("local LLM command is empty")
+
+    try:
+        process = subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except OSError as exc:
+        raise WorkflowError(f"cannot start local LLM command: {exc}") from exc
+
+    stdout, stderr = process.communicate(prompt)
+    if stdout:
+        stream.write(stdout)
+        if not stdout.endswith("\n"):
+            stream.write("\n")
+        stream.flush()
+
+    if process.returncode != 0:
+        message = stderr.strip() or f"local LLM exited with {process.returncode}"
+        raise WorkflowError(message)
+
+    return stdout.rstrip()

aop_launcher-0.0.1.dev0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: aop-launcher
+Version: 0.0.1.dev0
+Summary: Lightweight launcher for local AI agent workflows
+Author: aone
+License-Expression: MIT
+Keywords: agents,llm,workflow,yaml,terminal
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# aop_launcher
+
+Agent Orchestration Platform Launcher.
+
+`aop_launcher` is a tiny terminal runner for local AI agent workflows. It reads
+a YAML file, runs agents in sequence, optionally runs local shell tools for each
+agent, sends the prompt to a local LLM command, and streams the result to the
+terminal.
+
+This first `0.0.1.dev0` release is intentionally small. It does not provide
+remote execution, scheduling, retries, memory stores, or a hosted service.
+
+## Install
+
+```bash
+pip install aop-launcher
+```
+
+## Example workflow
+
+```yaml
+llm:
+  command: "ollama run llama3.2"
+
+tools:
+  now: "date"
+
+agents:
+  - name: planner
+    tools: ["now"]
+    prompt: |
+      Create a short plan for this task:
+      {input}
+
+      Tool results:
+      {tool_results}
+
+  - name: writer
+    prompt: |
+      Write the final answer from this plan:
+      {input}
+```
+
+Run it:
+
+```bash
+aop-launcher workflow.yml "Draft a release checklist"
+```
+
+You can also pass the LLM command from the terminal:
+
+```bash
+aop-launcher workflow.yml "hello" --llm-command "ollama run llama3.2"
+```
+

aop_launcher-0.0.1.dev0.dist-info/RECORD

@@ -0,0 +1,8 @@
+aop_launcher/__init__.py,sha256=C-yjkTeNaYmHT3cXYurhnpMemPBo0Ug7lPo_4qXZQG4,201
+aop_launcher/cli.py,sha256=-5V2txWhiLHAA1aL0ivCkzDdFPajsk4XzF5MSZsgV4s,1236
+aop_launcher/core.py,sha256=35FcNvOvMNGHS_gug9feu9sUF7DOkmuXQxNUiyf1mo8,4982
+aop_launcher-0.0.1.dev0.dist-info/METADATA,sha256=OzQYp8XA7X_5unVFGPVTyQFyTjSzh5iLrq0dwNH9uJo,1986
+aop_launcher-0.0.1.dev0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+aop_launcher-0.0.1.dev0.dist-info/entry_points.txt,sha256=HEjzM1tkXmlutwG2HpIlQVA7fPJVIW9hX4Fg9RSgvLY,55
+aop_launcher-0.0.1.dev0.dist-info/top_level.txt,sha256=7GK9ixyLSob29whXn3NujT_68XsnbNrMp67xwKjSYc8,13
+aop_launcher-0.0.1.dev0.dist-info/RECORD,,

aop_launcher-0.0.1.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aop_launcher-0.0.1.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aop-launcher = aop_launcher.cli:main

aop_launcher-0.0.1.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aop_launcher