action-platform 0.1.0__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,52 @@
+"""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,
+        draft: bool = False,
+    ) -> "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/branch.py

@@ -0,0 +1,36 @@
+"""`action-platform branch` command."""
+
+from __future__ import annotations
+
+import typer
+
+from action_platform.core import branching
+from action_platform.logging import logger
+
+
+def run(
+    kind: str = typer.Argument(
+        ...,
+        help="feature | bugfix | hotfix | release | "
+        + " | ".join(
+            k
+            for k in branching.KINDS
+            if k not in {"feature", "bugfix", "hotfix", "release"}
+        ),
+    ),
+    code: str = typer.Argument(
+        ..., help="Issue or ticket code: 42, PROJ-123, 1.4.0 for release"
+    ),
+    slug: str | None = typer.Argument(None, help="Optional words appended as a slug"),
+    push: bool = typer.Option(
+        True, "--push/--no-push", help="Push the new branch upstream"
+    ),
+) -> None:
+    """Start a branch: checkout the right base (develop or main), pull, create <kind>/<code>."""
+    branch = branching.start(kind, code, slug, push=push)
+    logger.info(
+        "on %s (from %s)%s",
+        branch.name,
+        branch.base,
+        " — pushed" if branch.pushed else "",
+    )

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/gitflow.py

@@ -0,0 +1,49 @@
+"""`action-platform gitflow` command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from action_platform.core import gitflow
+from action_platform.core.exception import ActionPlatformError
+
+console = Console()
+
+
+def run(
+    since: str | None = typer.Option(
+        None,
+        "--since",
+        help="Check commits after this ref (default: merge base with develop/main)",
+    ),
+    install: bool = typer.Option(
+        False,
+        "--install-hooks",
+        help="Install the bundled git hooks into .git/hooks and exit",
+    ),
+) -> None:
+    """Check the current branch and commits against git-flow and Conventional Commits."""
+    cwd = Path.cwd()
+
+    if install:
+        if gitflow.install_hooks(cwd):
+            console.print("[green]hooks installed[/green] (.git/hooks)")
+            return
+        raise ActionPlatformError("not a git repository")
+
+    report = gitflow.audit(cwd, since=since)
+    console.print(
+        f"branch [bold]{report.branch}[/bold], {report.checked_commits} commit(s) checked"
+    )
+
+    if report.ok:
+        console.print("[green]git-flow ok[/green]")
+        return
+
+    for problem in report.problems:
+        console.print(f"[red]✗[/red] {problem}")
+
+    raise typer.Exit(code=1)

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/install.py

@@ -0,0 +1,50 @@
+"""`action-platform install` command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from action_platform.core import install as installing
+
+console = Console()
+
+
+def run(
+    type_: str = typer.Option("web", "--type", help="web, library, docs, plugin"),
+    language: str | None = typer.Option(
+        None, "--language", help="python, go, node, php, java, rust (default: detected)"
+    ),
+    ci: str = typer.Option("github", "--ci", help="github, gitlab, jenkins"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be created"),
+) -> None:
+    """Install the platform in this repository: platform.toml, code quality, CI files (never overwritten) and git hooks into .git/hooks (always refreshed)."""
+    plan = installing.install(
+        Path.cwd(), type_=type_, language=language, ci=ci, dry_run=dry_run
+    )
+    verb = "would create" if dry_run else "created"
+    console.print(
+        f"[bold]{plan.root.name}[/bold] — {plan.language} {plan.type}, ci {plan.ci}"
+    )
+
+    for rel in plan.created:
+        console.print(f"  [green]+[/green] {rel}  ({verb})")
+
+    for rel in plan.skipped:
+        console.print(f"  [dim]= {rel}  (exists, kept)[/dim]")
+
+    if plan.hooks_installed:
+        console.print(
+            "  [green]✓[/green] git hooks installed (.git/hooks, unversioned)"
+        )
+
+    if dry_run or not plan.created:
+        return
+
+    console.print(
+        "\nnext: review the files, then "
+        '[bold]git add -A && git commit -m "chore(platform): install action-platform"[/bold] '
+        "— chore(platform) commits are allowed on main"
+    )

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/pr.py

@@ -0,0 +1,41 @@
+"""`action-platform pr` command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from action_platform.core import pullrequest
+
+console = Console()
+
+
+def run(
+    base: str | None = typer.Option(
+        None, "--base", help="Target branch (default from git-flow)"
+    ),
+    title: str | None = typer.Option(
+        None, "--title", help="Default: first commit on the branch"
+    ),
+    body: str | None = typer.Option(
+        None, "--body", help="Default: commits grouped by type"
+    ),
+    draft: bool = typer.Option(False, "--draft"),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Show target, title and body; open nothing"
+    ),
+) -> None:
+    """Open a pull request for the current branch: audits git-flow, picks the target, describes the commits."""
+    cwd = Path.cwd()
+
+    if dry_run:
+        proposal = pullrequest.propose(cwd, base=base, title=title)
+        console.print(f"[bold]{proposal.head}[/bold] → [bold]{proposal.base}[/bold]")
+        console.print(f"title: {proposal.title}\n")
+        console.print(body or proposal.body)
+        return
+
+    ref = pullrequest.open_pr(cwd, base=base, title=title, body=body, draft=draft)
+    console.print(f"[green]opened[/green] #{ref.number} {ref.url}")

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)