action-platform 0.1.1__py3-none-any.whl

action_platform/__init__.py

@@ -0,0 +1,10 @@
+"""Action Platform __init__ module."""
+
+__version__ = "0.1.0"
+__description__ = "🛠️ Action Platform padroniza init, release e deploy."
+
+from .core.config import Config
+from .core.context import Context
+from .core.action_platform import ActionPlatform
+
+__all__ = ["Config", "Context", "ActionPlatform"]

action_platform/abc/__init__.py

@@ -0,0 +1,7 @@
+"""Action Platform abstract base classes."""
+
+from .ci_runner import CIRunner
+from .deploy_target import DeployTarget
+from .source_host import SourceHost
+
+__all__ = ["CIRunner", "DeployTarget", "SourceHost"]

action_platform/abc/ci_runner.py

@@ -0,0 +1,25 @@
+"""CIRunner ABC."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Iterator
+
+if TYPE_CHECKING:
+    from action_platform.core.context import Context, RunRef, RunResult
+
+
+class CIRunner(ABC):
+    """CIRunner"""
+
+    name: str
+
+    @abstractmethod
+    def trigger(self, ctx: "Context", job: str, params: dict) -> "RunRef":
+        """Enqueue pipeline run."""
+
+    @abstractmethod
+    def wait(self, ctx: "Context", run: "RunRef", timeout: int = 1800) -> "RunResult":
+        """Block until pipeline finishes or timeout."""
+
+    @abstractmethod
+    def logs(self, ctx: "Context", run: "RunRef") -> Iterator[str]:
+        """Stream pipeline logs."""

action_platform/abc/deploy_target.py

@@ -0,0 +1,46 @@
+"""DeployTarget ABC — the lifecycle every deploy target answers to.
+
+Vocabulary mirrors what a deployment scope needs over its life: provision the
+target once, ship versions, move traffic, undo, inspect, tear down. A target
+that cannot do one of them raises NotImplementedError and the CLI says so.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from action_platform.core.context import Context, DeployResult, Diagnosis
+
+
+class DeployTarget(ABC):
+    """DeployTarget"""
+
+    name: str
+
+    @abstractmethod
+    def preflight(self, ctx: "Context") -> None:
+        """Validate credentials, tooling, artifacts. Raise DeployError otherwise."""
+
+    def create(self, ctx: "Context") -> None:
+        """Provision the target itself (stack, app, registry). Idempotent."""
+        raise NotImplementedError(f"{self.name} cannot create")
+
+    @abstractmethod
+    def deploy(self, ctx: "Context") -> "DeployResult":
+        """Ship the current version."""
+
+    def switch_traffic(self, ctx: "Context", weight: int) -> None:
+        """Move `weight` percent of traffic to the newest version (blue-green)."""
+        raise NotImplementedError(f"{self.name} cannot switch traffic")
+
+    def rollback(self, ctx: "Context", to_version: str | None = None) -> None:
+        """Revert to `to_version` or the previous one."""
+        raise NotImplementedError(f"{self.name} cannot rollback")
+
+    def diagnose(self, ctx: "Context") -> "Diagnosis":
+        """Health, last deploy, logs pointer."""
+        raise NotImplementedError(f"{self.name} cannot diagnose")
+
+    def delete(self, ctx: "Context") -> None:
+        """Tear the target down."""
+        raise NotImplementedError(f"{self.name} cannot delete")

action_platform/abc/source_host.py

@@ -0,0 +1,51 @@
+"""SourceHost ABC."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from action_platform.core.context import Context, PRRef, ReleaseRef
+
+
+class SourceHost(ABC):
+    """SourceHost"""
+
+    name: str
+
+    @abstractmethod
+    def detect(self, remote_url: str) -> bool:
+        """Return True if this provider handles remote_url."""
+
+    def create_repository(
+        self, repo: str, description: str = "", private: bool = False
+    ) -> str:
+        """Create the remote repository; return its clone URL."""
+        raise NotImplementedError(f"{self.name} cannot create repositories")
+
+    @abstractmethod
+    def create_tag(self, ctx: "Context", tag: str) -> None:
+        """Create annotated tag on remote."""
+
+    @abstractmethod
+    def create_release(
+        self,
+        ctx: "Context",
+        tag: str,
+        notes: str,
+        assets: list[Path] | None = None,
+        draft: bool = False,
+        prerelease: bool = False,
+    ) -> "ReleaseRef":
+        """Publish release on remote host."""
+
+    @abstractmethod
+    def open_pr(
+        self,
+        ctx: "Context",
+        base: str,
+        head: str,
+        title: str,
+        body: str,
+    ) -> "PRRef":
+        """Open pull/merge request."""

action_platform/cli/__init__.py

@@ -0,0 +1 @@
+"""Action Platform CLI package."""

action_platform/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Action Platform CLI commands."""

action_platform/cli/commands/cloud.py

@@ -0,0 +1,52 @@
+"""`action-platform cloud` commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from action_platform.core.generate import apply_cloud, read_platform
+from action_platform.core.templates import load_matrix
+from action_platform.logging import logger
+
+app = typer.Typer(
+    help="Apply deploy overlays to an existing project.", no_args_is_help=True
+)
+console = Console()
+
+
+@app.command("set")
+def set_(
+    name: str = typer.Argument(..., help="aws/lambda, docker, ..."),
+    project: Path = typer.Option(
+        None, "--project", "-p", help="Project directory (default: cwd)"
+    ),
+    update: bool = typer.Option(False, "--update", help="Refresh the templates cache"),
+) -> None:
+    """Apply a cloud overlay and set [deploy] target in platform.toml (replaces the previous one)."""
+    repo, matrix = load_matrix(update=update)
+    target = (project or Path.cwd()).resolve()
+
+    apply_cloud(repo, matrix.cloud(name), target)
+
+    logger.info("applied cloud %s to %s", name, target)
+
+
+@app.command("list")
+def list_(
+    project: Path = typer.Option(
+        None, "--project", "-p", help="Filter by what this project supports"
+    ),
+) -> None:
+    """List cloud overlays, optionally only those compatible with a project."""
+    _, matrix = load_matrix()
+    clouds = matrix.clouds
+
+    if project is not None:
+        meta = read_platform(project.resolve())
+        clouds = matrix.clouds_for(meta.get("type", ""), meta.get("language", ""))
+
+    for cloud in clouds:
+        console.print(f"[bold]{cloud.name}[/bold]  {cloud.description}")

action_platform/cli/commands/deploy.py

@@ -0,0 +1,90 @@
+"""`action-platform deploy | rollback | diagnose | destroy` commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from action_platform.core.action_platform import ActionPlatform
+from action_platform.core.config import Config
+from action_platform.core.exception import DeployError
+from action_platform.logging import logger
+from action_platform.settings import settings
+
+console = Console()
+
+TARGET = typer.Option(
+    None, "--target", help="Filter by target name (aws/lambda, docker, ...)"
+)
+STAGE = typer.Option(
+    None, "--stage", help="dev | prod (default: prod on main/master, else dev)"
+)
+
+
+def _tool() -> ActionPlatform:
+    return ActionPlatform(config=Config.from_toml(Path.cwd() / settings.CONFIG_FILE))
+
+
+def run(
+    target: str | None = TARGET,
+    stage: str | None = STAGE,
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    """Ship the current version to the [deploy] target in platform.toml."""
+    for r in _tool().deploy(target=target, dry_run=dry_run, stage=stage):
+        logger.info(
+            "deploy %s ok=%s version=%s url=%s", r.target, r.ok, r.version, r.url
+        )
+
+        if not r.ok:
+            raise DeployError(r.error or f"{r.target} failed")
+
+
+def rollback(
+    to_version: str | None = typer.Argument(
+        None, help="Version to return to (default: previous)"
+    ),
+    target: str | None = TARGET,
+    stage: str | None = STAGE,
+) -> None:
+    """Return the target to a previous version."""
+    try:
+        _tool().rollback(target=target, to_version=to_version, stage=stage)
+    except NotImplementedError as e:
+        raise DeployError(str(e)) from e
+    logger.info("rollback done")
+
+
+def diagnose(target: str | None = TARGET, stage: str | None = STAGE) -> None:
+    """Health, status and URL of the deployed target."""
+    try:
+        results = _tool().diagnose(target=target, stage=stage)
+    except NotImplementedError as e:
+        raise DeployError(str(e)) from e
+    for d in results:
+        mark = "[green]ok[/green]" if d.ok else "[red]not ok[/red]"
+        console.print(f"[bold]{d.target}[/bold] {mark} {d.status}")
+
+        if d.url:
+            console.print(f"  url: {d.url}")
+
+        for k, v in d.details.items():
+            console.print(f"  {k}: {v}")
+
+
+def destroy(
+    target: str | None = TARGET,
+    stage: str | None = STAGE,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Tear the target down. Irreversible."""
+    if not yes and not typer.confirm("Delete the deployed target?"):
+        raise typer.Abort()
+
+    try:
+        _tool().destroy(target=target, stage=stage)
+    except NotImplementedError as e:
+        raise DeployError(str(e)) from e
+    logger.info("destroy done")

action_platform/cli/commands/init.py

@@ -0,0 +1,136 @@
+"""`action-platform init` command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from action_platform.core.exception import TemplateError
+from action_platform.core.generate import apply_cloud, generate_project, push_project
+from action_platform.core.templates import Matrix, load_matrix
+from action_platform.logging import logger
+
+CI_PROVIDERS = ["github", "gitlab", "jenkins"]
+
+console = Console()
+
+
+def run(
+    type_: str | None = typer.Argument(
+        None, metavar="TYPE", help="web, library, mcp, ..."
+    ),
+    stack: str | None = typer.Argument(None, help="python, go, node, ..."),
+    template: str | None = typer.Argument(
+        None, help="fastapi, gin, ... (default per stack)"
+    ),
+    name: str | None = typer.Option(None, "--name", "-n", help="Project name"),
+    ci: str | None = typer.Option(
+        None, "--ci", help="CI provider: " + ", ".join(CI_PROVIDERS)
+    ),
+    cloud: str | None = typer.Option(
+        None, "--cloud", help="Deploy overlay: aws/lambda, docker, ..."
+    ),
+    output: Path | None = typer.Option(
+        None, "--output", "-o", help="Where to create the project"
+    ),
+    push: bool = typer.Option(
+        True,
+        "--push/--no-push",
+        help="Create the remote repo via [source_host] and push (default: on)",
+    ),
+    private: bool = typer.Option(False, "--private", help="With --push: private repo"),
+    list_: bool = typer.Option(False, "--list", "-l", help="Show the template matrix"),
+    update: bool = typer.Option(False, "--update", help="Refresh the templates cache"),
+) -> None:
+    """Bootstrap a project from the templates matrix."""
+    repo, matrix = load_matrix(update=update)
+
+    if list_:
+        print_matrix(matrix)
+        return
+
+    if type_ is None:
+        type_ = choose("type", matrix.types())
+    if stack is None and matrix.stacks(type_):
+        stack = choose("stack", matrix.stacks(type_))
+    if template is None and stack is not None:
+        leaves = matrix.templates(type_, stack)
+        if len(leaves) > 1:
+            template = choose("template", [leaf.template for leaf in leaves])
+
+    leaf = matrix.resolve(type_, stack, template)
+
+    if name is None:
+        name = typer.prompt("project name")
+    if ci is None and leaf.type != "empty":
+        ci = choose("ci", CI_PROVIDERS)
+    if ci is not None and ci not in CI_PROVIDERS:
+        raise TemplateError(f"unknown ci: {ci} (available: {', '.join(CI_PROVIDERS)})")
+
+    project = generate_project(
+        repo, leaf, name=name, ci=ci, output=output or Path.cwd()
+    )
+    logger.info("created %s", project)
+
+    if cloud is not None:
+        apply_cloud(repo, matrix.cloud(cloud), project)
+        logger.info("applied cloud %s", cloud)
+
+    if push:
+        url = push_project(project, private=private)
+        logger.info("pushed to %s", url)
+
+
+def choose(label: str, options: list[str]) -> str:
+    console.print(f"[bold]{label}[/bold]")
+    for i, opt in enumerate(options, 1):
+        console.print(f"  {i}. {opt}")
+    while True:
+        raw = typer.prompt(f"{label} [1-{len(options)}]")
+        if raw in options:
+            return raw
+        if raw.isdigit() and 1 <= int(raw) <= len(options):
+            return options[int(raw) - 1]
+        console.print("[red]invalid choice[/red]")
+
+
+def print_matrix(matrix: Matrix) -> None:
+    table = Table(title="Projects")
+    table.add_column("type")
+    table.add_column("stack")
+    table.add_column("template")
+    table.add_column("description")
+    for leaf in matrix.leaves:
+        tpl = f"{leaf.template} *" if leaf.default else leaf.template
+        table.add_row(leaf.type, leaf.stack, tpl, leaf.description)
+    console.print(table)
+    console.print("[dim]* default template for the stack[/dim]\n")
+
+    clouds = Table(title="Clouds")
+    clouds.add_column("cloud")
+    clouds.add_column("types")
+    clouds.add_column("languages")
+    clouds.add_column("description")
+    for cloud in matrix.clouds:
+        clouds.add_row(
+            cloud.name,
+            ", ".join(cloud.types) or "any",
+            ", ".join(cloud.languages) or "any",
+            cloud.description,
+        )
+    console.print(clouds)
+
+    services = Table(title="Services")
+    services.add_column("service")
+    services.add_column("providers")
+    services.add_column("description")
+
+    for service in matrix.services:
+        services.add_row(
+            service.name, ", ".join(service.providers), service.description
+        )
+
+    console.print(services)

action_platform/cli/commands/mcp.py

@@ -0,0 +1,26 @@
+"""`action-platform mcp` command."""
+
+from __future__ import annotations
+
+import typer
+
+from action_platform.core.exception import ActionPlatformError
+
+
+def run(
+    http: bool = typer.Option(
+        False, "--http", help="Serve over streamable HTTP instead of stdio"
+    ),
+    host: str = typer.Option("127.0.0.1", "--host"),
+    port: int = typer.Option(8765, "--port", help="Port for --http"),
+) -> None:
+    """Run the embedded MCP server so AI agents can scaffold, deploy and operate projects."""
+    try:
+        from action_platform.mcp.server import main
+    except ModuleNotFoundError as e:
+        raise ActionPlatformError(
+            "MCP support is not installed: pip install 'action-platform[mcp]'"
+        ) from e
+
+    argv = ["--http", "--host", host, "--port", str(port)] if http else []
+    main(argv)

action_platform/cli/commands/release.py

@@ -0,0 +1,22 @@
+"""`action-platform release` command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from action_platform.core.config import Config
+from action_platform.core.action_platform import ActionPlatform
+from action_platform.logging import logger
+
+
+def run(
+    level: str = typer.Argument("patch", help="patch | minor | major | X.Y.Z"),
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    """Bump version, generate changelog, tag, and publish release."""
+    config = Config.from_toml(Path.cwd() / "platform.toml")
+    tool = ActionPlatform(config=config)
+    ctx = tool.release(level=level, dry_run=dry_run)
+    logger.info("release done: %s", ctx.next_version)

action_platform/cli/commands/service.py

@@ -0,0 +1,50 @@
+"""`action-platform service` commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from action_platform.core.generate import apply_service
+from action_platform.core.templates import load_matrix
+from action_platform.logging import logger
+
+app = typer.Typer(
+    help="Add application dependencies (database, cache, storage) to a project.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command("add")
+def add(
+    name: str = typer.Argument(..., help="postgres, redis, s3, ..."),
+    provider: str | None = typer.Option(
+        None, "--provider", help="docker, aws-rds, aws, ... (default: first listed)"
+    ),
+    project: Path = typer.Option(
+        None, "--project", "-p", help="Project directory (default: cwd)"
+    ),
+    update: bool = typer.Option(False, "--update", help="Refresh the templates cache"),
+) -> None:
+    """Add services/<name>/ with up + link scripts and record it in platform.toml."""
+    repo, matrix = load_matrix(update=update)
+    target = (project or Path.cwd()).resolve()
+
+    apply_service(repo, matrix.service(name), target, provider=provider)
+
+    logger.info("added service %s to %s", name, target)
+
+
+@app.command("list")
+def list_() -> None:
+    """List available services and their providers."""
+    _, matrix = load_matrix()
+
+    for service in matrix.services:
+        console.print(
+            f"[bold]{service.name}[/bold]  {service.description}  "
+            f"[dim]({', '.join(service.providers)})[/dim]"
+        )

action_platform/cli/setup.py

@@ -0,0 +1,27 @@
+"""Typer app assembly."""
+
+import typer
+
+from action_platform.cli.commands import cloud as cloud_cmd
+from action_platform.cli.commands import deploy as deploy_cmd
+from action_platform.cli.commands import init as init_cmd
+from action_platform.cli.commands import mcp as mcp_cmd
+from action_platform.cli.commands import release as release_cmd
+from action_platform.cli.commands import service as service_cmd
+
+app = typer.Typer(
+    name="action-platform",
+    help="Standardize init, release, and deploy across any stack.",
+    no_args_is_help=True,
+    pretty_exceptions_enable=False,
+)
+
+app.command("init")(init_cmd.run)
+app.command("release")(release_cmd.run)
+app.command("deploy")(deploy_cmd.run)
+app.command("rollback")(deploy_cmd.rollback)
+app.command("diagnose")(deploy_cmd.diagnose)
+app.command("destroy")(deploy_cmd.destroy)
+app.command("mcp")(mcp_cmd.run)
+app.add_typer(cloud_cmd.app, name="cloud")
+app.add_typer(service_cmd.app, name="service")

action_platform/core/__init__.py

@@ -0,0 +1 @@
+"""Action Platform core module."""

action_platform/core/action_platform.py

@@ -0,0 +1,63 @@
+"""ActionPlatform orchestrator."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from action_platform.core import pipeline
+from action_platform.core.config import Config
+from action_platform.core.context import Context, DeployResult, Diagnosis
+
+
+class ActionPlatform:
+    """
+    Import:
+        from action_platform import ActionPlatform, Config
+
+    Example:
+        tool = ActionPlatform(config=Config(...))
+        tool.release("patch")
+        tool.deploy()
+
+    Args:
+        config (Config): configuration with injected providers.
+        repo_root (Path): repository root. Defaults to cwd.
+
+    Attributes:
+        config (Config):
+        repo_root (Path):
+    """
+
+    def __init__(
+        self, config: Config | None = None, repo_root: Path | None = None
+    ) -> None:
+        self.config = config or Config()
+        self.repo_root = repo_root or Path.cwd()
+
+    def release(self, level: str = "patch", dry_run: bool = False) -> Context:
+        return pipeline.release(self.config, level, self.repo_root, dry_run=dry_run)
+
+    def deploy(
+        self, target: str | None = None, dry_run: bool = False, stage: str | None = None
+    ) -> list[DeployResult]:
+        return pipeline.deploy(
+            self.config, target, self.repo_root, dry_run=dry_run, stage=stage
+        )
+
+    def rollback(
+        self,
+        target: str | None = None,
+        to_version: str | None = None,
+        stage: str | None = None,
+    ) -> None:
+        pipeline.rollback(
+            self.config, target, self.repo_root, to_version=to_version, stage=stage
+        )
+
+    def diagnose(
+        self, target: str | None = None, stage: str | None = None
+    ) -> list[Diagnosis]:
+        return pipeline.diagnose(self.config, target, self.repo_root, stage=stage)
+
+    def destroy(self, target: str | None = None, stage: str | None = None) -> None:
+        pipeline.destroy(self.config, target, self.repo_root, stage=stage)