spawnio 1.0.5__py3-none-any.whl

spawn/generators/project_generator.py

@@ -0,0 +1,115 @@
+import datetime
+import json
+import shutil
+from pathlib import Path
+
+from spawn import __version__
+from spawn.templates.shared_content import (
+    README_CONTENT,
+    GITIGNORE_CONTENT,
+    AGENTS_MD_CONTENT,
+)
+from spawn.core.models import ProjectConfig
+from spawn.core.registry import instantiate_template
+from spawn.utils.git import initialize_git
+from spawn.utils.uv import initialize_uv, install_packages
+from spawn.core.exceptions import SpawnError
+from spawn.utils.console import console
+
+
+class ProjectGenerator:
+    def generate(self, config: ProjectConfig) -> Path:
+        template = instantiate_template(config)
+
+        if template is None:
+            raise SpawnError(
+                f"Unknown template: {config.template}"
+            )
+
+        project_path = Path(config.name)
+
+        if project_path.exists():
+            raise SpawnError(
+                f"Directory '{config.name}' already exists."
+            )
+
+        try:
+            project_path.mkdir()
+
+            context = {"project_name": config.name}
+            template.generate(project_path, context)
+
+            readme_content = template.get_readme_content(context)
+            if readme_content is None:
+                readme_content = README_CONTENT.format(project_name=config.name)
+
+            readme_path = project_path / "README.md"
+            readme_path.write_text(readme_content, encoding="utf-8")
+
+            agents_md_content = template.get_agents_md_content(context)
+            if agents_md_content is None:
+                agents_md_content = AGENTS_MD_CONTENT.format(project_name=config.name)
+
+            agents_md_path = project_path / "AGENTS.md"
+            agents_md_path.write_text(agents_md_content, encoding="utf-8")
+
+            if config.generate_claude_md:
+                claude_md_path = project_path / "CLAUDE.md"
+                claude_md_path.write_text(agents_md_content, encoding="utf-8")
+
+            gitignore_path = project_path / ".gitignore"
+
+            gitignore_path.write_text(
+                GITIGNORE_CONTENT,
+                encoding="utf-8",
+            )
+
+            if config.use_git:
+                console.print(
+                    "[yellow]Initializing Git...[/yellow]"
+                )
+                initialize_git(project_path)
+
+            initialize_uv(project_path)
+
+            deps = template.get_dependencies()
+            if deps:
+                console.print(
+                    "[yellow]Installing dependencies...[/yellow]"
+                )
+                install_packages(project_path, deps)
+
+            template.post_install(project_path)
+
+            meta_dir = project_path / ".spawn"
+            meta_dir.mkdir()
+            meta_file = meta_dir / "meta.json"
+            meta_file.write_text(
+                json.dumps(
+                    {
+                        "intent": config.template,
+                        "framework": config.framework,
+                        "provider": config.provider,
+                        "spawn_version": __version__,
+                        "created_at": datetime.datetime.now(
+                            datetime.timezone.utc
+                        ).isoformat(),
+                        "generator": "blueprint",
+                        "git": config.use_git,
+                        "uv": True,
+                        "source": None,
+                    },
+                    indent=2,
+                ),
+                encoding="utf-8",
+            )
+
+        except OSError as e:
+            shutil.rmtree(project_path, ignore_errors=True)
+            raise SpawnError(str(e)) from e
+
+        except BaseException:
+            shutil.rmtree(project_path, ignore_errors=True)
+            raise
+
+        return project_path

spawn/github/exceptions.py

@@ -0,0 +1,5 @@
+from spawn.core.exceptions import SpawnError
+
+
+class GitHubPublishError(SpawnError):
+    """Raised when GitHub publishing fails."""

spawn/github/publisher.py

@@ -0,0 +1,69 @@
+from pathlib import Path
+
+from spawn.github.validators import (
+    is_valid_github_url,
+)
+from spawn.github.exceptions import (
+    GitHubPublishError,
+)
+from spawn.core.exceptions import SpawnError
+
+from spawn.utils.git import (
+    add_all,
+    commit,
+    rename_main_branch,
+    add_remote,
+    push_origin_main,
+    remote_exists,
+    is_git_repository,
+)
+
+
+class GitHubPublisher:
+    def publish(
+        self,
+        project_path: Path,
+        repo_url: str,
+    ) -> None:
+
+        if not project_path.exists():
+            raise GitHubPublishError(
+                f"Project path does not exist: {project_path}"
+            )
+
+        if not is_valid_github_url(repo_url):
+            raise GitHubPublishError(
+                "Invalid GitHub repository URL."
+            )
+
+        if not is_git_repository(project_path):
+            raise GitHubPublishError(
+                "Project is not a Git repository."
+            )
+
+        if remote_exists(project_path):
+            raise GitHubPublishError(
+                "Origin remote already exists."
+            )
+
+        try:
+            add_all(project_path)
+
+            commit(
+                project_path,
+                "Initial commit",
+            )
+
+            rename_main_branch(project_path)
+
+            add_remote(
+                project_path,
+                repo_url,
+            )
+
+            push_origin_main(project_path)
+
+        except SpawnError as exc:
+            raise GitHubPublishError(
+                str(exc)
+            ) from exc

spawn/github/validators.py

@@ -0,0 +1,23 @@
+import re
+
+
+_GITHUB_PATTERNS = (
+    r"^https://github\.com/[a-zA-Z0-9][a-zA-Z0-9_-]*/[a-zA-Z0-9][a-zA-Z0-9_.-]*/?$",
+    r"^https://github\.com/[a-zA-Z0-9][a-zA-Z0-9_-]*/[a-zA-Z0-9][a-zA-Z0-9_.-]*\.git$",
+    r"^git@github\.com:[a-zA-Z0-9][a-zA-Z0-9_-]*/[a-zA-Z0-9][a-zA-Z0-9_.-]*\.git$",
+)
+
+
+def is_valid_github_url(url: str) -> bool:
+    """
+    Validate supported GitHub repository URLs.
+    """
+    url = url.strip()
+
+    if not url:
+        return False
+
+    return any(
+        re.match(pattern, url)
+        for pattern in _GITHUB_PATTERNS
+    )

spawn/templates/agent/__init__.py

@@ -0,0 +1,182 @@
+from pathlib import Path
+
+from spawn.templates.base import BaseTemplate
+from spawn.templates.agent.content import (
+    INIT_CONTENT,
+    AGENT_PROMPT_TXT_CONTENT,
+    SETTINGS_CONTENT,
+    CALCULATOR_TOOL_CONTENT,
+    PYDANTIC_AI_AGENT_CONTENT,
+    OPENAI_AGENTS_AGENT_CONTENT,
+    MAIN_CONTENT,
+    PYDANTIC_AI_TEST_CONTENT,
+    OPENAI_AGENTS_TEST_CONTENT,
+    CONFTEST_CONTENT,
+    GITHUB_ACTIONS_CI_BASE,
+    GITHUB_ACTIONS_CI_RUFF_STEP,
+    GITHUB_ACTIONS_CI_PYTEST_STEP,
+    ENV_PYDANTIC_OPENAI,
+    ENV_PYDANTIC_ANTHROPIC,
+    ENV_PYDANTIC_GEMINI,
+    ENV_PYDANTIC_OPENROUTER,
+    ENV_PYDANTIC_OLLAMA,
+    ENV_PYDANTIC_GROQ,
+    ENV_OPENAI_AGENTS_OPENAI,
+    ENV_OPENAI_AGENTS_OPENROUTER,
+    make_readme,
+    make_agents_md,
+)
+
+AGENT_FOLDERS = [
+    "src/agent",
+    "src/tools",
+    "src/prompts",
+    "src/config",
+    "tests",
+]
+
+# Maps (framework, provider) → agent run.py content
+_AGENT_MAP: dict[tuple[str, str], str] = {
+    ("pydantic-ai",   "openai"):     PYDANTIC_AI_AGENT_CONTENT,
+    ("pydantic-ai",   "anthropic"):  PYDANTIC_AI_AGENT_CONTENT,
+    ("pydantic-ai",   "gemini"):     PYDANTIC_AI_AGENT_CONTENT,
+    ("pydantic-ai",   "openrouter"): PYDANTIC_AI_AGENT_CONTENT,
+    ("pydantic-ai",   "ollama"):     PYDANTIC_AI_AGENT_CONTENT,
+    ("pydantic-ai",   "groq"):       PYDANTIC_AI_AGENT_CONTENT,
+    ("openai-agents", "openai"):     OPENAI_AGENTS_AGENT_CONTENT,
+    ("openai-agents", "openrouter"): OPENAI_AGENTS_AGENT_CONTENT,
+}
+
+# Maps (framework, provider) → env example
+_ENV_MAP: dict[tuple[str, str], str] = {
+    ("pydantic-ai",   "openai"):     ENV_PYDANTIC_OPENAI,
+    ("pydantic-ai",   "anthropic"):  ENV_PYDANTIC_ANTHROPIC,
+    ("pydantic-ai",   "gemini"):     ENV_PYDANTIC_GEMINI,
+    ("pydantic-ai",   "openrouter"): ENV_PYDANTIC_OPENROUTER,
+    ("pydantic-ai",   "ollama"):     ENV_PYDANTIC_OLLAMA,
+    ("pydantic-ai",   "groq"):       ENV_PYDANTIC_GROQ,
+    ("openai-agents", "openai"):     ENV_OPENAI_AGENTS_OPENAI,
+    ("openai-agents", "openrouter"): ENV_OPENAI_AGENTS_OPENROUTER,
+}
+
+# Maps framework → test content
+_TEST_MAP: dict[str, str] = {
+    "pydantic-ai":   PYDANTIC_AI_TEST_CONTENT,
+    "openai-agents": OPENAI_AGENTS_TEST_CONTENT,
+}
+
+AGENT_PROVIDER_MAP: dict[str, list[str]] = {
+    "pydantic-ai":   ["openai", "anthropic", "gemini", "openrouter", "ollama", "groq"],
+    "openai-agents": ["openai", "openrouter"],
+}
+
+
+def get_supported_providers(framework: str) -> list[str]:
+    return AGENT_PROVIDER_MAP.get(framework, ["openai"])
+
+
+def _build_files(
+    agent_content: str,
+    test_content: str,
+    env_content: str,
+) -> list:
+    return [
+        ("src/__init__.py",              INIT_CONTENT),
+        ("src/agent/__init__.py",        INIT_CONTENT),
+        ("src/agent/run.py",             agent_content),
+        ("src/tools/__init__.py",        INIT_CONTENT),
+        ("src/tools/calculator.py",      CALCULATOR_TOOL_CONTENT),
+        ("src/prompts/__init__.py",      INIT_CONTENT),
+        ("src/prompts/agent_prompt.txt", AGENT_PROMPT_TXT_CONTENT),
+        ("src/config/__init__.py",       INIT_CONTENT),
+        ("src/config/settings.py",       SETTINGS_CONTENT),
+        ("src/main.py",                  MAIN_CONTENT),
+        ("tests/__init__.py",            INIT_CONTENT),
+        ("tests/conftest.py",            CONFTEST_CONTENT),
+        ("tests/test_agent.py",          test_content),
+        (".env.example",                 env_content),
+    ]
+
+
+class AgentTemplate(BaseTemplate):
+    def __init__(
+        self,
+        framework: str | None = None,
+        provider: str | None = None,
+        extras: list[str] | None = None,
+    ) -> None:
+        self.framework = framework or "pydantic-ai"
+        self.provider  = provider  or "openai"
+        self.extras    = extras    or []
+
+        key = (self.framework, self.provider)
+        agent_content = _AGENT_MAP.get(key, PYDANTIC_AI_AGENT_CONTENT)
+        env_content   = _ENV_MAP.get(key, ENV_PYDANTIC_OPENAI)
+        test_content  = _TEST_MAP.get(self.framework, PYDANTIC_AI_TEST_CONTENT)
+
+        super().__init__(
+            name="AI Agent",
+            folders=list(AGENT_FOLDERS),
+            starter_files=_build_files(agent_content, test_content, env_content),
+            next_steps=[
+                "cd {project_name}",
+                "Rename .env.example to .env and fill in your API key",
+                "uv run python -m src.main",
+            ],
+        )
+
+    def get_readme_content(self, context: dict) -> str | None:
+        raw = make_readme(self.framework, self.provider)
+        return raw.format_map(context)
+
+    def get_agents_md_content(self, context: dict) -> str | None:
+        raw = make_agents_md(self.framework, self.provider)
+        return raw.format_map(context)
+
+    def get_dependencies(self) -> list[str]:
+        dep_map: dict[tuple[str, str], list[str]] = {
+            ("pydantic-ai",   "openai"):     ["pydantic-ai", "python-dotenv"],
+            ("pydantic-ai",   "anthropic"):  ["pydantic-ai", "python-dotenv"],
+            ("pydantic-ai",   "gemini"):     ["pydantic-ai", "python-dotenv"],
+            ("pydantic-ai",   "openrouter"): ["pydantic-ai", "python-dotenv"],
+            ("pydantic-ai",   "ollama"):     ["pydantic-ai", "python-dotenv"],
+            ("pydantic-ai",   "groq"):       ["pydantic-ai[groq]", "python-dotenv"],
+            ("openai-agents", "openai"):     ["openai-agents", "python-dotenv"],
+            ("openai-agents", "openrouter"): ["openai-agents", "python-dotenv"],
+        }
+
+        base = list(dep_map.get(
+            (self.framework, self.provider),
+            ["pydantic-ai", "python-dotenv"],
+        ))
+
+        if "pytest" in self.extras:
+            base.append("pytest")
+        if "ruff" in self.extras:
+            base.append("ruff")
+
+        return base
+
+    def post_install(self, project_path: Path) -> None:
+        pyproject = project_path / "pyproject.toml"
+        current   = pyproject.read_text(encoding="utf-8")
+        additions = ""
+
+        if "pytest" in self.extras:
+            additions += "\n[tool.pytest.ini_options]\ntestpaths = [\"tests\"]\n"
+
+        if "ruff" in self.extras:
+            additions += "\n[tool.ruff]\nline-length = 88\n"
+
+        if additions:
+            pyproject.write_text(current + additions, encoding="utf-8")
+
+        if "github-actions" in self.extras:
+            workflows_path = project_path / ".github" / "workflows"
+            workflows_path.mkdir(parents=True, exist_ok=True)
+            ci = GITHUB_ACTIONS_CI_BASE
+            if "ruff" in self.extras:
+                ci += GITHUB_ACTIONS_CI_RUFF_STEP
+            if "pytest" in self.extras:
+                ci += GITHUB_ACTIONS_CI_PYTEST_STEP
+            (workflows_path / "ci.yml").write_text(ci, encoding="utf-8")