multiagent-init 0.1.0__py3-none-any.whl

multiagent_init/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

multiagent_init/cli.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import sys
+
+from .generator import generate_project
+from .wizard import run_wizard
+
+
+def main() -> int:
+    try:
+        config = run_wizard()
+        destination = generate_project(config)
+
+        print()
+        print("🎉 Done!")
+        print()
+        print("Next steps:")
+        print()
+        print(f"  cd {destination.name}")
+        print("  python3 -m venv .venv")
+        print("  source .venv/bin/activate  # macOS/Linux")
+        print("  pip install .")
+        print("  python main.py")
+        print()
+
+        return 0
+
+    except KeyboardInterrupt:
+        print("\n\nCancelled.")
+        return 130
+
+    except (ValueError, FileExistsError, OSError) as exc:
+        print(f"\nError: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

multiagent_init/generator.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .templates_data import (
+    AGENT_TEMPLATES,
+    CONFIG_TEMPLATE,
+    DOCKER_FILE,
+    FRAMEWORK_FILES,
+    ORCHESTRATOR_TEMPLATES,
+    PROVIDER_ENV_VARS,
+    TEST_TEMPLATE,
+    TOOL_FILE,
+)
+
+DEFAULT_AGENT_CLASSES = {
+    "Researcher": "ResearcherAgent",
+    "Writer": "WriterAgent",
+    "Reviewer": "ReviewerAgent",
+    "Planner": "PlannerAgent",
+    "Executor": "ExecutorAgent",
+}
+
+
+def _safe_project_name(value: str) -> str:
+    value = value.strip()
+
+    if not value:
+        raise ValueError("project name cannot be empty")
+
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_-]*", value):
+        raise ValueError("invalid project name")
+
+    return value
+
+
+def _safe_package_name(project_name: str) -> str:
+    value = re.sub(r"[^A-Za-z0-9_]", "_", project_name).lower()
+
+    if value[0].isdigit():
+        value = f"_{value}"
+
+    return value
+
+
+def agent_to_module(name: str) -> str:
+    value = re.sub(r"[^A-Za-z0-9]+", "_", name.strip())
+    value = re.sub(r"_+", "_", value).strip("_").lower()
+
+    if not value:
+        value = "agent"
+
+    if value[0].isdigit():
+        value = f"agent_{value}"
+
+    return value
+
+
+def agent_to_class(name: str) -> str:
+    parts = re.findall(r"[A-Za-z0-9]+", name.strip())
+
+    if not parts:
+        return "Agent"
+
+    class_name = "".join(part.capitalize() for part in parts)
+
+    if class_name[0].isdigit():
+        class_name = f"Agent{class_name}"
+
+    return f"{class_name}Agent"
+
+
+def _write(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+
+
+def generate_project(config: dict) -> Path:
+    project_name = _safe_project_name(config["project_name"])
+    package_name = _safe_package_name(project_name)
+    destination = Path.cwd() / project_name
+
+    if destination.exists():
+        if not destination.is_dir():
+            raise FileExistsError(f"'{project_name}' already exists and is not a directory")
+
+        if any(destination.iterdir()):
+            raise FileExistsError(
+                f"directory '{project_name}' already exists and is not empty"
+            )
+    else:
+        destination.mkdir(parents=True)
+
+    package_dir = destination / "src" / package_name
+
+    framework_pyproject = FRAMEWORK_FILES[config["framework"]]
+    framework_pyproject = framework_pyproject.replace("{{PROJECT_NAME}}", project_name)
+    framework_pyproject = framework_pyproject.replace("{{PACKAGE_NAME}}", package_name)
+
+    _write(destination / "pyproject.toml", framework_pyproject)
+
+    _write(
+        destination / "README.md",
+        _render_readme(config, package_name),
+    )
+
+    provider_env_var = PROVIDER_ENV_VARS[config["provider"]]
+
+    _write(
+        destination / ".env",
+        f"MODEL_NAME=your-model\n{provider_env_var}=\n",
+    )
+
+    _write(
+        destination / ".gitignore",
+        "__pycache__/\n*.py[cod]\n.venv/\n.env\n.pytest_cache/\n",
+    )
+
+    _write(package_dir / "__init__.py", '"""Generated package."""\n')
+
+    config_content = CONFIG_TEMPLATE.replace("{{PROVIDER_ENV_VAR}}", provider_env_var)
+    config_content = config_content.replace("{{PROVIDER}}", config["provider"])
+    _write(package_dir / "config.py", config_content)
+
+    agent_template = AGENT_TEMPLATES.get(config["framework"], AGENT_TEMPLATES["basic"])
+    orchestrator_template = ORCHESTRATOR_TEMPLATES.get(
+        config["framework"], ORCHESTRATOR_TEMPLATES["basic"]
+    )
+
+    agent_files = []
+
+    for agent_name in config["agent_names"]:
+        module_name = agent_to_module(agent_name)
+        class_name = agent_to_class(agent_name)
+
+        agent_files.append(
+            {
+                "name": agent_name,
+                "module": module_name,
+                "class": class_name,
+            }
+        )
+
+        content = agent_template
+        content = content.replace("{{AGENT_NAME}}", agent_name)
+        content = content.replace("{{AGENT_CLASS}}", class_name)
+
+        _write(
+            package_dir / "agents" / f"{module_name}.py",
+            content,
+        )
+
+    _write(
+        package_dir / "agents" / "__init__.py",
+        '"""Generated agents."""\n',
+    )
+
+    imports = "\n".join(
+        f"from {package_name}.agents.{item['module']} import {item['class']}"
+        for item in agent_files
+    )
+
+    instances = ",\n        ".join(
+        f"{item['class']}()"
+        for item in agent_files
+    )
+
+    main_content = f"""from __future__ import annotations
+
+import logging
+
+{imports}
+
+from {package_name} import config
+from {package_name}.workflow.orchestrator import Orchestrator
+
+
+def main() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    )
+
+    config.validate()
+
+    agents = [
+        {instances}
+    ]
+
+    orchestrator = Orchestrator(agents)
+
+    result = orchestrator.run(
+        "Build a short report about multi-agent systems."
+    )
+
+    print("\\n=== Final result ===")
+    print(result)
+
+
+if __name__ == "__main__":
+    main()
+"""
+
+    _write(destination / "main.py", main_content)
+
+    _write(
+        package_dir / "workflow" / "__init__.py",
+        '"""Workflow and orchestration."""\n',
+    )
+
+    _write(
+        package_dir / "workflow" / "orchestrator.py",
+        orchestrator_template,
+    )
+
+    if config["include_tools"]:
+        _write(
+            package_dir / "tools" / "__init__.py",
+            '"""Tools available to agents."""\n',
+        )
+        _write(package_dir / "tools" / "web_search.py", TOOL_FILE)
+
+    if config["include_tests"]:
+        test_content = TEST_TEMPLATE.replace(
+            "{{TEST_IMPORTS}}",
+            "\n".join(
+                f"from {package_name}.agents.{item['module']} import {item['class']}"
+                for item in agent_files
+            ),
+        )
+
+        assertions = "\n".join(
+            f'        self.assertIn("{item["name"]}", {item["class"]}().run(task))'
+            for item in agent_files
+        )
+
+        test_content = test_content.replace("{{ASSERTIONS}}", assertions)
+
+        _write(
+            destination / "tests" / "test_agents.py",
+            test_content,
+        )
+
+    if config["include_docker"]:
+        docker_content = DOCKER_FILE.replace("{{PACKAGE_NAME}}", package_name)
+        _write(destination / "Dockerfile", docker_content)
+
+    print()
+    print("Creating project...")
+    print()
+    print("✓ Agents")
+    print("✓ Workflow")
+
+    if config["include_tools"]:
+        print("✓ Tools")
+
+    print("✓ Configuration")
+
+    if config["include_tests"]:
+        print("✓ Tests")
+
+    if config["include_docker"]:
+        print("✓ Docker")
+
+    print("✓ README")
+
+    return destination
+
+
+def _render_readme(config: dict, package_name: str) -> str:
+    agents = "\n".join(
+        f"- `{name}`"
+        for name in config["agent_names"]
+    )
+
+    return f"""# {config["project_name"]}
+
+Generated by **multiagent-init**.
+
+## Configuration
+
+- Framework: `{config["framework"]}`
+- Model provider: `{config["provider"]}`
+- Agent configuration: `{config["agent_mode"]}`
+- Number of agents: `{config["agent_count"]}`
+
+## Agents
+
+{agents}
+
+## Structure
+
+```text
+src/{package_name}/
+    agents/       Individual agents
+    workflow/     Orchestration
+    tools/        Optional tools
+    config.py     Configuration
+tests/            Optional tests
+main.py           Entry point (python main.py)
+```
+
+## Run
+
+```bash
+pip install .
+python main.py
+```
+
+Set your provider's API key in `.env` before running - `config.validate()` fails
+fast with a clear error if it's missing.
+
+Replace the placeholder agent logic with your actual LLM/framework implementation.
+"""

multiagent_init/templates_data.py

@@ -0,0 +1,370 @@
+FRAMEWORK_FILES = {
+    "basic": """[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{{PROJECT_NAME}}"
+version = "0.1.0"
+description = "A multi-agent AI application."
+requires-python = ">=3.9"
+dependencies = []
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+""",
+    "langgraph": """[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{{PROJECT_NAME}}"
+version = "0.1.0"
+description = "A LangGraph multi-agent AI application."
+requires-python = ">=3.9"
+dependencies = [
+  "langgraph>=0.2",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+""",
+    "crewai": """[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{{PROJECT_NAME}}"
+version = "0.1.0"
+description = "A CrewAI multi-agent AI application."
+requires-python = ">=3.9"
+dependencies = [
+  "crewai>=0.80",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+""",
+    "autogen": """[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{{PROJECT_NAME}}"
+version = "0.1.0"
+description = "An AutoGen multi-agent AI application."
+requires-python = ">=3.9"
+dependencies = [
+  "autogen-agentchat>=0.4",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+""",
+}
+
+PROVIDER_ENV_VARS = {
+    "openai": "OPENAI_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+    "google": "GOOGLE_API_KEY",
+}
+
+CONFIG_TEMPLATE = """import os
+
+MODEL_NAME = os.getenv("MODEL_NAME", "your-model")
+{{PROVIDER_ENV_VAR}} = os.getenv("{{PROVIDER_ENV_VAR}}")
+
+
+def validate() -> None:
+    \"\"\"Fail fast if the required API key is missing.\"\"\"
+    if not {{PROVIDER_ENV_VAR}}:
+        raise RuntimeError(
+            "Missing required environment variable '{{PROVIDER_ENV_VAR}}' for "
+            "provider '{{PROVIDER}}'. Set it in your .env file."
+        )
+"""
+
+AGENT_TEMPLATES = {
+    "basic": """class {{AGENT_CLASS}}:
+    \"\"\"{{AGENT_NAME}} agent.\"\"\"
+
+    name = "{{AGENT_NAME}}"
+
+    def run(self, task: str) -> str:
+        # TODO: connect this agent to your LLM/framework.
+        return f"[{{AGENT_NAME}}] Completed: {task}"
+""",
+    "langgraph": """class {{AGENT_CLASS}}:
+    \"\"\"{{AGENT_NAME}} node.\"\"\"
+
+    name = "{{AGENT_NAME}}"
+
+    def run(self, task: str) -> str:
+        # TODO: connect this node to your LLM/framework.
+        return f"[{{AGENT_NAME}}] Completed: {task}"
+
+    def __call__(self, state: dict) -> dict:
+        \"\"\"LangGraph node entry point - transforms and returns the graph state.\"\"\"
+        state["result"] = self.run(state["task"])
+        state["task"] = state["result"]
+        return state
+""",
+    "crewai": """from crewai import Agent
+
+
+class {{AGENT_CLASS}}:
+    \"\"\"{{AGENT_NAME}} agent.\"\"\"
+
+    name = "{{AGENT_NAME}}"
+
+    def __init__(self) -> None:
+        self.agent = Agent(
+            role="{{AGENT_NAME}}",
+            goal="Complete tasks assigned to the {{AGENT_NAME}} role.",
+            backstory="An AI agent specialized in {{AGENT_NAME}} tasks.",
+            # TODO: configure an LLM, e.g. llm="gpt-4o-mini".
+            allow_delegation=False,
+        )
+
+    def run(self, task: str) -> str:
+        # TODO: wrap `task` in a crewai.Task and execute it via a Crew.
+        return f"[{{AGENT_NAME}}] Completed: {task}"
+""",
+    "autogen": """from autogen_agentchat.agents import AssistantAgent
+
+
+class {{AGENT_CLASS}}:
+    \"\"\"{{AGENT_NAME}} agent.\"\"\"
+
+    name = "{{AGENT_NAME}}"
+
+    def build(self, model_client) -> AssistantAgent:
+        \"\"\"Build a real AutoGen AssistantAgent once you have a model client.\"\"\"
+        return AssistantAgent(
+            name="{{AGENT_NAME}}",
+            model_client=model_client,
+            system_message="You are the {{AGENT_NAME}} agent.",
+        )
+
+    def run(self, task: str) -> str:
+        # TODO: connect this agent to your LLM/framework.
+        return f"[{{AGENT_NAME}}] Completed: {task}"
+""",
+}
+
+ORCHESTRATOR_TEMPLATES = {
+    "basic": """from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AgentExecutionError(RuntimeError):
+    \"\"\"Raised when an agent fails during orchestration.\"\"\"
+
+
+class Orchestrator:
+    \"\"\"Simple sequential multi-agent orchestrator.\"\"\"
+
+    def __init__(self, agents):
+        self.agents = list(agents)
+
+    def run(self, task: str) -> str:
+        current = task
+
+        for agent in self.agents:
+            logger.info("Running agent: %s", agent.name)
+
+            try:
+                current = agent.run(current)
+            except Exception as exc:
+                logger.exception("Agent '%s' failed", agent.name)
+                raise AgentExecutionError(f"Agent '{agent.name}' failed: {exc}") from exc
+
+        return current
+""",
+    "langgraph": """from __future__ import annotations
+
+import logging
+
+from langgraph.graph import END, START, StateGraph
+
+logger = logging.getLogger(__name__)
+
+
+class AgentExecutionError(RuntimeError):
+    \"\"\"Raised when the LangGraph execution fails.\"\"\"
+
+
+class Orchestrator:
+    \"\"\"LangGraph-based sequential multi-agent orchestrator.\"\"\"
+
+    def __init__(self, agents):
+        self.agents = list(agents)
+        self.graph = self._build_graph()
+
+    def _build_graph(self):
+        graph = StateGraph(dict)
+
+        previous = START
+        for index, agent in enumerate(self.agents):
+            node_id = f"node_{index}"
+            graph.add_node(node_id, agent)
+            graph.add_edge(previous, node_id)
+            previous = node_id
+
+        graph.add_edge(previous, END)
+
+        return graph.compile()
+
+    def run(self, task: str) -> str:
+        logger.info("Invoking LangGraph with %d node(s)", len(self.agents))
+
+        try:
+            final_state = self.graph.invoke({"task": task, "result": ""})
+        except Exception as exc:
+            logger.exception("LangGraph execution failed")
+            raise AgentExecutionError(f"LangGraph execution failed: {exc}") from exc
+
+        return final_state["result"]
+""",
+    "crewai": """from __future__ import annotations
+
+import logging
+
+from crewai import Crew, Task
+
+logger = logging.getLogger(__name__)
+
+
+class AgentExecutionError(RuntimeError):
+    \"\"\"Raised when an agent fails during orchestration.\"\"\"
+
+
+class Orchestrator:
+    \"\"\"CrewAI-based multi-agent orchestrator.\"\"\"
+
+    def __init__(self, agents):
+        self.agents = list(agents)
+
+    def build_crew(self, task: str) -> Crew:
+        \"\"\"Build a real CrewAI Crew for the given task.
+
+        Once your agents have an LLM configured, use
+        `orchestrator.build_crew(task).kickoff()` instead of `run()`.
+        \"\"\"
+        tasks = [
+            Task(
+                description=task,
+                agent=agent.agent,
+                expected_output="A completed response for the assigned step.",
+            )
+            for agent in self.agents
+        ]
+
+        return Crew(agents=[agent.agent for agent in self.agents], tasks=tasks)
+
+    def run(self, task: str) -> str:
+        current = task
+
+        for agent in self.agents:
+            logger.info("Running agent: %s", agent.name)
+
+            try:
+                current = agent.run(current)
+            except Exception as exc:
+                logger.exception("Agent '%s' failed", agent.name)
+                raise AgentExecutionError(f"Agent '{agent.name}' failed: {exc}") from exc
+
+        return current
+""",
+    "autogen": """from __future__ import annotations
+
+import logging
+
+from autogen_agentchat.teams import RoundRobinGroupChat
+
+logger = logging.getLogger(__name__)
+
+
+class AgentExecutionError(RuntimeError):
+    \"\"\"Raised when an agent fails during orchestration.\"\"\"
+
+
+class Orchestrator:
+    \"\"\"AutoGen-based multi-agent orchestrator.\"\"\"
+
+    def __init__(self, agents):
+        self.agents = list(agents)
+
+    def build_team(self, model_client) -> RoundRobinGroupChat:
+        \"\"\"Build a real AutoGen team once you have a model client.
+
+        Once your agents have an LLM configured, run the team with
+        `await team.run(task=...)` instead of `run()`.
+        \"\"\"
+        participants = [agent.build(model_client) for agent in self.agents]
+
+        return RoundRobinGroupChat(participants)
+
+    def run(self, task: str) -> str:
+        current = task
+
+        for agent in self.agents:
+            logger.info("Running agent: %s", agent.name)
+
+            try:
+                current = agent.run(current)
+            except Exception as exc:
+                logger.exception("Agent '%s' failed", agent.name)
+                raise AgentExecutionError(f"Agent '{agent.name}' failed: {exc}") from exc
+
+        return current
+""",
+}
+
+TOOL_FILE = """class WebSearchTool:
+    \"\"\"Placeholder for a web-search integration.\"\"\"
+
+    def search(self, query: str) -> str:
+        return f"Search provider placeholder: {query}"
+"""
+
+TEST_TEMPLATE = """import unittest
+
+{{TEST_IMPORTS}}
+
+
+class AgentTests(unittest.TestCase):
+    def test_agents_return_output(self):
+        task = "test task"
+{{ASSERTIONS}}
+
+
+if __name__ == "__main__":
+    unittest.main()
+"""
+
+DOCKER_FILE = """FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install --no-cache-dir .
+
+CMD ["python", "-m", "{{PACKAGE_NAME}}"]
+"""

multiagent_init/wizard.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import re
+
+import questionary
+from questionary import Style
+
+NAME_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]*$")
+AGENT_PATTERN = re.compile(r"^[A-Za-z][A-Za-z0-9 _-]*$")
+
+STYLE = Style(
+    [
+        ("qmark", "fg:cyan bold"),
+        ("question", "bold"),
+        ("answer", "fg:cyan"),
+        ("pointer", "fg:cyan bold"),
+        ("highlighted", "fg:cyan bold"),
+    ]
+)
+
+
+def _valid_project_name(value: str) -> bool:
+    return bool(NAME_PATTERN.fullmatch(value.strip()))
+
+
+def _valid_agent_name(value: str) -> bool:
+    return bool(AGENT_PATTERN.fullmatch(value.strip()))
+
+
+def _ask_agent_names(count: int) -> list[str]:
+    names = []
+
+    for index in range(1, count + 1):
+        name = questionary.text(
+            f"Agent {index} name:",
+            validate=lambda value: (
+                True
+                if _valid_agent_name(value)
+                else "Use letters, numbers, spaces, '-' or '_'."
+            ),
+            style=STYLE,
+        ).ask()
+
+        if name is None:
+            raise KeyboardInterrupt
+
+        names.append(name.strip())
+
+    return names
+
+
+def run_wizard() -> dict:
+    print()
+    print("🚀 MultiAgent Init")
+    print()
+
+    project_name = questionary.text(
+        "Project name:",
+        validate=lambda value: (
+            True
+            if _valid_project_name(value)
+            else "Use letters, numbers, '-' or '_' and start with a letter/number."
+        ),
+        style=STYLE,
+    ).ask()
+
+    if project_name is None:
+        raise KeyboardInterrupt
+
+    framework = questionary.select(
+        "Select a framework:",
+        choices=[
+            questionary.Choice("Basic", value="basic"),
+            questionary.Choice("LangGraph", value="langgraph"),
+            questionary.Choice("CrewAI", value="crewai"),
+            questionary.Choice("AutoGen", value="autogen"),
+        ],
+        default="basic",
+        style=STYLE,
+    ).ask()
+
+    provider = questionary.select(
+        "Select model provider:",
+        choices=[
+            questionary.Choice("OpenAI", value="openai"),
+            questionary.Choice("Anthropic", value="anthropic"),
+            questionary.Choice("Google", value="google"),
+        ],
+        default="openai",
+        style=STYLE,
+    ).ask()
+
+    agent_count_choice = questionary.select(
+        "Number of agents:",
+        choices=["3", "2", "4", "5", "Custom"],
+        default="3",
+        style=STYLE,
+    ).ask()
+
+    if agent_count_choice == "Custom":
+        agent_count = questionary.text(
+            "How many agents?",
+            default="6",
+            validate=lambda value: (
+                True
+                if value.isdigit() and 1 <= int(value) <= 50
+                else "Enter a number between 1 and 50."
+            ),
+            style=STYLE,
+        ).ask()
+
+        if agent_count is None:
+            raise KeyboardInterrupt
+
+        agent_count = int(agent_count)
+    else:
+        agent_count = int(agent_count_choice)
+
+    agent_mode = questionary.select(
+        "Agent configuration:",
+        choices=[
+            questionary.Choice("Default agents", value="default"),
+            questionary.Choice("Custom agents", value="custom"),
+        ],
+        default="default",
+        style=STYLE,
+    ).ask()
+
+    default_names = [
+        "Researcher",
+        "Writer",
+        "Reviewer",
+        "Planner",
+        "Executor",
+    ]
+
+    if agent_mode == "default":
+        if agent_count <= len(default_names):
+            agent_names = default_names[:agent_count]
+        else:
+            agent_names = default_names[:]
+            for index in range(len(default_names) + 1, agent_count + 1):
+                agent_names.append(f"Agent {index}")
+    else:
+        agent_names = _ask_agent_names(agent_count)
+
+    include_tools = questionary.confirm(
+        "Include tools?",
+        default=True,
+        style=STYLE,
+    ).ask()
+
+    include_tests = questionary.confirm(
+        "Include tests?",
+        default=True,
+        style=STYLE,
+    ).ask()
+
+    include_docker = questionary.confirm(
+        "Include Docker?",
+        default=False,
+        style=STYLE,
+    ).ask()
+
+    return {
+        "project_name": project_name.strip(),
+        "framework": framework,
+        "provider": provider,
+        "agent_count": agent_count,
+        "agent_mode": agent_mode,
+        "agent_names": agent_names,
+        "include_tools": include_tools,
+        "include_tests": include_tests,
+        "include_docker": include_docker,
+    }

multiagent_init-0.1.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: multiagent-init
+Version: 0.1.0
+Summary: Interactive CLI for generating multi-agent AI project boilerplates.
+Author-email: Pavan Sekhar Mandavilli <pavanmandavilli2004@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Pavanmandavilli/multiagent-init
+Project-URL: Repository, https://github.com/Pavanmandavilli/multiagent-init
+Project-URL: Issues, https://github.com/Pavanmandavilli/multiagent-init/issues
+Keywords: multi-agent,agents,ai,scaffolding,cli,generator
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: questionary<3.0.0,>=2.0.0
+Dynamic: license-file
+
+# 🚀 MultiAgent Init
+
+Interactive CLI for generating a clean multi-agent AI project.
+
+## Install
+
+```bash
+pip install multiagent-init
+```
+
+## Run
+
+```bash
+multiagent-init
+```
+
+## Wizard
+
+The CLI asks for:
+
+1. Project name
+2. Framework
+3. Model provider
+4. Number of agents
+5. Default or custom agents
+6. Optional tools
+7. Optional tests
+8. Optional Docker
+
+### Example
+
+```text
+🚀 MultiAgent Init
+
+? Project name: research-team
+
+? Select a framework:
+❯ Basic
+  LangGraph
+  CrewAI
+  AutoGen
+
+? Select model provider:
+❯ OpenAI
+  Anthropic
+  Google
+
+? Number of agents:
+❯ 3
+  2
+  4
+  5
+  Custom
+
+? Agent configuration:
+❯ Default agents
+  Custom agents
+
+? Agent 1 name: Market Researcher
+? Agent 2 name: Data Analyst
+? Agent 3 name: Report Writer
+
+? Include tools? Yes
+? Include tests? Yes
+? Include Docker? No
+
+Creating project...
+
+✓ Agents
+✓ Workflow
+✓ Tools
+✓ Configuration
+✓ Tests
+✓ README
+
+🎉 Done!
+```
+
+## Generated project
+
+Custom agent names are converted into safe Python filenames and class names.
+
+Example:
+
+```text
+Market Researcher → market_researcher.py → MarketResearcherAgent
+Data Analyst      → data_analyst.py      → DataAnalystAgent
+Report Writer     → report_writer.py     → ReportWriterAgent
+```
+
+## Development
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e .
+python -m unittest discover -s tests -v
+```
+
+Build:
+
+```bash
+python -m pip install --upgrade build
+python -m build
+```
+
+## Publish
+
+TestPyPI:
+
+```bash
+python -m pip install --upgrade twine
+python -m twine upload --repository testpypi dist/*
+```
+
+PyPI:
+
+```bash
+python -m twine upload dist/*
+```
+
+For CI/CD, configure PyPI Trusted Publishing with GitHub Actions.
+
+## License
+
+MIT

multiagent_init-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+multiagent_init/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+multiagent_init/cli.py,sha256=KSCkKerzzimHHFErQLfy2bFYv9x5VDDyyO6ki0vT9Fg,842
+multiagent_init/generator.py,sha256=1AONIxfB9dYToaEcJqJKdpQoFetQGsmF_RnfQTsOSJs,7726
+multiagent_init/templates_data.py,sha256=qRWw9vVceVjkt9QVcihFA4nvJ1d4KYDEUkD2myhwBFk,9468
+multiagent_init/wizard.py,sha256=3d3YA9e1MFIf00KdbOlA9w-kYvBEYPsipZUDzAhClRc,4527
+multiagent_init-0.1.0.dist-info/licenses/LICENSE,sha256=qAWvkf1ylseZfzIyN09FEw7XxS6MDeJ7ZiL1qH5fVqA,1081
+multiagent_init-0.1.0.dist-info/METADATA,sha256=6dHalPlVeoBdroiWLRgzm6zeROkd5o2h4MeAEi6wBzc,2628
+multiagent_init-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+multiagent_init-0.1.0.dist-info/entry_points.txt,sha256=-Yzt8FY_8k0fuLS7zS3oqEvmLX-qqVQYXUKL42mJjsY,61
+multiagent_init-0.1.0.dist-info/top_level.txt,sha256=rLfcUGuLZ-VSZxeFphJKtzsXupC2ZObn5b0TEJrAwJI,16
+multiagent_init-0.1.0.dist-info/RECORD,,

multiagent_init-0.1.0.dist-info/WHEEL

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

multiagent_init-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+multiagent-init = multiagent_init.cli:main

multiagent_init-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mandavilli. Pavan sekhar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

multiagent_init-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+multiagent_init