iac-code 0.5.0__tar.gz → 0.6.0__tar.gz

{iac_code-0.5.0 → iac_code-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.5.0
+Version: 0.6.0
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -14,6 +14,7 @@ Provides-Extra: a2a
 Provides-Extra: a2a-grpc
 Provides-Extra: a2a-redis
 Provides-Extra: a2a-signing
+Provides-Extra: diagram
 Provides-Extra: http
 License-File: LICENSE
 

{iac_code-0.5.0 → iac_code-0.6.0}/pyproject.toml

@@ -58,6 +58,7 @@ a2a-grpc = [
 a2a-redis = [
     "redis>=5.0.0",
 ]
+diagram = ["termaid>=0.1; python_version >= '3.11'"]
 
 [dependency-groups]
 dev = [

iac_code-0.6.0/setup.py

@@ -0,0 +1,285 @@
+"""Custom build hook to inject __release_date__ at build time."""
+
+import platform
+import re
+import shutil
+import subprocess
+import sys
+from datetime import date
+from pathlib import Path
+
+from setuptools import find_namespace_packages, setup
+from setuptools.command.build_py import build_py
+from setuptools.command.sdist import sdist
+
+INIT_PATH = Path("src/iac_code/__init__.py")
+LOCALES_DIR = Path("src/iac_code/i18n/locales")
+PROJECT_ROOT = Path(__file__).resolve().parent
+IAC_ALIYUN_REFERENCES_DIR = PROJECT_ROOT / "src/iac_code/skills/bundled/iac_aliyun/references"
+SELLING_IAC_ALIYUN_SKILLS = (
+    "iac-aliyun-template-generating",
+    "iac-aliyun-cost",
+    "iac-aliyun-deploying",
+)
+INSTALL_REQUIRES = [
+    "anthropic>=0.40",
+    "pydantic>=2.0",
+    "typer>=0.9.0",
+    "rich>=13.0",
+    "pyyaml>=6.0",
+    "pyperclip>=1.8.0",
+    "openai>=1.50",
+    "httpx>=0.27.0",
+    "packaging>=24.0",
+    "tiktoken>=0.7.0",
+    "jsonschema>=4.20",
+    "alibabacloud-ros20190910>=3.0.0",
+    "alibabacloud-credentials>=0.3.0",
+    "loguru>=0.7.0",
+    "opentelemetry-distro>=0.48b0",
+    "opentelemetry-exporter-otlp>=1.27.0",
+    "agent-client-protocol>=0.9.0",
+    "pillow==12.2.0",
+    "cryptography>=42.0",
+    "keyring>=25.0",
+    "tree-sitter>=0.25,<0.26",
+    "tree-sitter-bash>=0.25,<0.26",
+]
+EXTRAS_REQUIRE = {
+    "http": [
+        "starlette>=0.39.0",
+        "uvicorn[standard]>=0.30.0",
+    ],
+    "a2a": [
+        "a2a-sdk[http-server,signing]>=1.0.2,<2",
+        "cryptography>=42.0",
+        "starlette>=0.39.0",
+        "uvicorn[standard]>=0.30.0",
+    ],
+    "a2a-signing": [
+        "a2a-sdk[signing]>=1.0.2,<2",
+    ],
+    "a2a-grpc": [
+        "grpcio>=1.60.0",
+        "grpcio-status>=1.60.0",
+    ],
+    "a2a-redis": [
+        "redis>=5.0.0",
+    ],
+    "diagram": [
+        "termaid>=0.1; python_version >= '3.11'",
+    ],
+}
+PACKAGE_DATA = {
+    "iac_code": [
+        "**/*.yml",
+        "**/*.yaml",
+        "**/*.json",
+        "**/*.md",
+        "**/*.rego",
+        "**/*.mo",
+        "**/*.po",
+    ],
+}
+
+
+def _read_version():
+    content = INIT_PATH.read_text(encoding="utf-8")
+    match = re.search(r'^__version__\s*=\s*"([^"]+)"', content, flags=re.MULTILINE)
+    if not match:
+        raise RuntimeError("unable to read package version from %s" % INIT_PATH)
+    return match.group(1)
+
+
+def _read_long_description():
+    readme = Path("README.md")
+    return readme.read_text(encoding="utf-8") if readme.is_file() else ""
+
+
+def _try_import_babel():
+    """Try importing babel, return (read_po, write_mo) or None."""
+    try:
+        from babel.messages.mofile import write_mo
+        from babel.messages.pofile import read_po
+
+        return read_po, write_mo
+    except ImportError:
+        return None
+
+
+def _run(cmd):
+    subprocess.check_call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def _ensure_babel():
+    """Import babel, trying every available install method. Raise on total failure."""
+    result = _try_import_babel()
+    if result:
+        return result
+
+    attempts = []
+
+    # 1) pip install babel
+    try:
+        _run([sys.executable, "-m", "pip", "install", "babel"])
+        result = _try_import_babel()
+        if result:
+            return result
+    except Exception as exc:
+        attempts.append("pip install babel -> %s" % exc)
+
+    # 2) ensurepip + pip install babel
+    try:
+        _run([sys.executable, "-m", "ensurepip", "--default-pip"])
+        _run([sys.executable, "-m", "pip", "install", "babel"])
+        result = _try_import_babel()
+        if result:
+            return result
+    except Exception as exc:
+        attempts.append("ensurepip + pip -> %s" % exc)
+
+    # 3) apt-get install python3-babel on Linux builders
+    if sys.platform == "linux":
+        try:
+            _run(["apt-get", "update", "-qq"])
+            _run(["apt-get", "install", "-y", "-qq", "python3-babel"])
+            result = _try_import_babel()
+            if result:
+                return result
+        except Exception as exc:
+            attempts.append("apt-get install python3-babel -> %s" % exc)
+
+    # 4) download get-pip.py, bootstrap pip, then pip install babel
+    try:
+        import os
+        import tempfile
+
+        try:
+            from urllib.request import urlretrieve
+        except ImportError:
+            from urllib import urlretrieve
+
+        fd, get_pip = tempfile.mkstemp(suffix=".py")
+        os.close(fd)
+        urlretrieve("https://bootstrap.pypa.io/get-pip.py", get_pip)
+        _run([sys.executable, get_pip, "--break-system-packages", "--quiet"])
+        os.remove(get_pip)
+        _run([sys.executable, "-m", "pip", "install", "babel"])
+        result = _try_import_babel()
+        if result:
+            return result
+    except Exception as exc:
+        attempts.append("get-pip.py + pip -> %s" % exc)
+
+    raise RuntimeError(
+        "babel is required to compile translations. All install methods failed:\n  " + "\n  ".join(attempts)
+    )
+
+
+def _compile_translations():
+    """Compile .po -> .mo for all locales."""
+    if not LOCALES_DIR.exists():
+        raise RuntimeError("locales directory not found: %s" % LOCALES_DIR)
+    po_files = sorted(LOCALES_DIR.rglob("*.po"))
+    if not po_files:
+        raise RuntimeError("no .po files found under %s" % LOCALES_DIR)
+    read_po, write_mo = _ensure_babel()
+    for po_file in po_files:
+        mo_file = po_file.with_suffix(".mo")
+        with open(po_file, "rb") as f:
+            catalog = read_po(f)
+        with open(mo_file, "wb") as f:
+            write_mo(f, catalog)
+        print("compiled %s -> %s" % (po_file, mo_file))
+
+
+def _replace_release_date():
+    if platform.system() == 'Darwin':
+        return
+    content = INIT_PATH.read_text(encoding="utf-8")
+    today = date.today().isoformat()
+    content = re.sub(
+        r'^__release_date__\s*=\s*".*"',
+        f'__release_date__ = "{today}"',
+        content,
+        flags=re.MULTILINE,
+    )
+    INIT_PATH.write_text(content, encoding="utf-8")
+
+
+def _copy_selling_skill_references_to_package_root(package_root) -> None:
+    """Expand selling-skill reference symlinks into real dirs under an iac_code package root."""
+    if not IAC_ALIYUN_REFERENCES_DIR.is_dir():
+        raise RuntimeError("references directory not found: %s" % IAC_ALIYUN_REFERENCES_DIR)
+
+    package_root = Path(package_root)
+    for skill_name in SELLING_IAC_ALIYUN_SKILLS:
+        target = package_root / "pipeline" / "selling" / "skills" / skill_name / "references"
+        if target.is_symlink() or target.is_file():
+            target.unlink()
+        elif target.exists():
+            shutil.rmtree(target)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(IAC_ALIYUN_REFERENCES_DIR, target)
+
+
+def _copy_selling_skill_references(build_lib: str) -> None:
+    """Expand selling-skill reference symlinks into real dirs for installed artifacts."""
+    _copy_selling_skill_references_to_package_root(Path(build_lib) / "iac_code")
+
+
+def _copy_selling_skill_references_to_sdist_release_tree(base_dir: str) -> None:
+    """Expand selling-skill references inside an sdist release tree."""
+    _copy_selling_skill_references_to_package_root(Path(base_dir) / "src" / "iac_code")
+
+
+class InjectReleaseDateBuildPy(build_py):
+    """Override build_py to stamp __release_date__ before copying source files."""
+
+    def run(self):
+        _replace_release_date()
+        _compile_translations()
+        super().run()
+        _copy_selling_skill_references(self.build_lib)
+
+
+class CompileTranslationsSdist(sdist):
+    """Override sdist to compile translations before packaging source."""
+
+    def run(self):
+        _replace_release_date()
+        _compile_translations()
+        super().run()
+
+    def make_release_tree(self, base_dir, files):
+        super().make_release_tree(base_dir, files)
+        _copy_selling_skill_references_to_sdist_release_tree(base_dir)
+
+
+setup(
+    name="iac_code",
+    version=_read_version(),
+    description="Your AI-powered Infrastructure as Code assistant",
+    long_description=_read_long_description(),
+    long_description_content_type="text/markdown",
+    python_requires=">=3.10",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
+    ],
+    packages=find_namespace_packages(where="src"),
+    package_dir={"": "src"},
+    include_package_data=True,
+    package_data=PACKAGE_DATA,
+    install_requires=INSTALL_REQUIRES,
+    extras_require=EXTRAS_REQUIRE,
+    entry_points={"console_scripts": ["iac-code=iac_code.cli.main:app"]},
+    cmdclass={
+        "build_py": InjectReleaseDateBuildPy,
+        "sdist": CompileTranslationsSdist,
+    }
+)

iac_code-0.6.0/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.6.0"
+__release_date__ = "2026-06-15"

{iac_code-0.5.0 → iac_code-0.6.0}/src/iac_code/a2a/agent_card.py

@@ -20,10 +20,17 @@ from google.protobuf.json_format import ParseDict
 from iac_code import __version__
 from iac_code.a2a.exposure import format_a2a_exposure_types
 from iac_code.a2a.parts import supported_input_mime_types
+from iac_code.a2a.pipeline_events import PIPELINE_EVENTS_EXTENSION_URI
 from iac_code.a2a.signing import sign_agent_card_dict
+from iac_code.i18n import _
+from iac_code.pipeline.config import RunMode, get_run_mode
 
 IAC_CODE_ARTIFACT_METADATA_EXTENSION_URI = "urn:iac-code:a2a:artifact-metadata:v1"
+IAC_CODE_PIPELINE_EVENTS_EXTENSION_URI = PIPELINE_EVENTS_EXTENSION_URI
 IAC_CODE_THINKING_EXPOSURE_EXTENSION_URI = "urn:iac-code:a2a:thinking-exposure:v1"
+CANONICAL_CALLER_EXTENSION_URIS = {
+    IAC_CODE_PIPELINE_EVENTS_EXTENSION_URI,
+}
 
 
 def _base_url(host: str, port: int) -> str:
@@ -168,8 +175,31 @@ def build_agent_card(
             )
             ParseDict({"enabledTypes": enabled_types}, extension.params)
             card.capabilities.extensions.append(extension)
-    for item in _iter_agent_extensions(agent_extensions):
+    for item in _iter_agent_extensions(agent_extensions, excluded_uris=CANONICAL_CALLER_EXTENSION_URIS):
         card.capabilities.extensions.append(_agent_extension_from_dict(item))
+    pipeline_events_extension = AgentExtension(
+        uri=IAC_CODE_PIPELINE_EVENTS_EXTENSION_URI,
+        description=_(
+            "Optional iac-code pipeline event extension for state snapshots, replay, interrupts, "
+            "and parallel candidate streams."
+        ),
+        required=False,
+    )
+    run_mode = get_run_mode()
+    ParseDict(
+        {
+            "schemaVersion": "1.0",
+            "enabled": run_mode == RunMode.PIPELINE,
+            "mode": run_mode.value,
+            "supportsSnapshot": True,
+            "supportsReplay": True,
+            "supportsInterrupts": True,
+            "supportsParallelCandidates": True,
+            "stateEndpoint": "/iac-code/pipeline/state",
+        },
+        pipeline_events_extension.params,
+    )
+    card.capabilities.extensions.append(pipeline_events_extension)
 
     if token_enabled:
         card.security_schemes["bearerAuth"].http_auth_security_scheme.CopyFrom(HTTPAuthSecurityScheme(scheme="bearer"))
@@ -231,7 +261,12 @@ def _agent_extension_from_dict(item: dict[str, Any]) -> AgentExtension:
     return extension
 
 
-def _iter_agent_extensions(value: Any) -> list[dict[str, Any]]:
+def _iter_agent_extensions(value: Any, *, excluded_uris: set[str] | None = None) -> list[dict[str, Any]]:
     if not isinstance(value, list):
         return []
-    return [item for item in value if isinstance(item, dict) and isinstance(item.get("uri"), str)]
+    blocked_uris = excluded_uris or set()
+    return [
+        item
+        for item in value
+        if isinstance(item, dict) and isinstance(item.get("uri"), str) and item["uri"] not in blocked_uris
+    ]

{iac_code-0.5.0 → iac_code-0.6.0}/src/iac_code/a2a/app.py

@@ -13,6 +13,8 @@ from pathlib import Path
 from time import time
 from typing import Awaitable, Callable
 
+from a2a.auth.user import User
+from a2a.server.context import ServerCallContext
 from a2a.server.routes import create_jsonrpc_routes, create_rest_routes
 from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
 from starlette.applications import Starlette
@@ -23,6 +25,7 @@ from starlette.responses import JSONResponse, Response
 from starlette.routing import BaseRoute, Route
 
 from iac_code.a2a.agent_card import agent_card_to_client_dict
+from iac_code.i18n import _
 
 _V03_JSONRPC_METHODS = frozenset(
     {
@@ -38,6 +41,20 @@ _V03_JSONRPC_METHODS = frozenset(
         "agent/getAuthenticatedExtendedCard",
     }
 )
+_MAX_AFTER_SEQUENCE_DIGITS = 20
+
+
+class _PrincipalUser(User):
+    def __init__(self, principal: str) -> None:
+        self._principal = principal
+
+    @property
+    def is_authenticated(self) -> bool:
+        return True
+
+    @property
+    def user_name(self) -> str:
+        return self._principal
 
 
 def resolve_token(cli_token: str | None) -> str | None:
@@ -197,6 +214,7 @@ def create_app(
         auto_approve_permissions=auto_approve_permissions,
         thinking_exposure=thinking_exposure,
     )
+    from iac_code.a2a.pipeline_recovery import A2APipelineRecoveryService
 
     @asynccontextmanager
     async def lifespan(app: Starlette):
@@ -227,9 +245,33 @@ def create_app(
             return Response(status_code=304, headers=card_cache_headers)
         return JSONResponse(card_data, headers=card_cache_headers)
 
+    recovery_service = A2APipelineRecoveryService(task_store=components.task_store)
+
+    async def get_pipeline_state(request: Request) -> JSONResponse:
+        context_id = request.query_params.get("contextId") or None
+        task_id = request.query_params.get("taskId") or None
+        if not context_id and not task_id:
+            return JSONResponse({"error": _("contextId or taskId is required")}, status_code=400)
+
+        after_sequence, parse_error = _parse_after_sequence(request.query_params.get("afterSequence"))
+        if parse_error is not None:
+            return JSONResponse({"error": parse_error}, status_code=400)
+
+        try:
+            state = await recovery_service.get_state(
+                context_id=context_id,
+                task_id=task_id,
+                after_sequence=after_sequence,
+                call_context=_call_context_from_request(request),
+            )
+        except ValueError as exc:
+            return JSONResponse({"error": str(exc)}, status_code=404)
+        return JSONResponse(state)
+
     routes: list[BaseRoute] = [
         Route("/health", health, methods=["GET"]),
         Route(AGENT_CARD_WELL_KNOWN_PATH, get_agent_card, methods=["GET"]),
+        Route("/iac-code/pipeline/state", get_pipeline_state, methods=["GET"]),
     ]
     jsonrpc_endpoint = create_jsonrpc_routes(components.handler, rpc_url="/", enable_v0_3_compat=True)[0].endpoint
 
@@ -251,11 +293,32 @@ def create_app(
     return app
 
 
+def _call_context_from_request(request: Request) -> ServerCallContext | None:
+    user = request.scope.get("user")
+    principal = getattr(user, "username", None) or getattr(user, "display_name", None)
+    if not isinstance(principal, str) or not principal:
+        return None
+    return ServerCallContext(user=_PrincipalUser(principal))
+
+
 def _agent_card_etag(card: dict[str, object]) -> str:
     body = json.dumps(card, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
     return f'"sha256-{hashlib.sha256(body).hexdigest()}"'
 
 
+def _parse_after_sequence(value: str | None) -> tuple[int | None, str | None]:
+    if value is None or value == "":
+        return None, None
+    if len(value) > _MAX_AFTER_SEQUENCE_DIGITS:
+        return None, _("afterSequence must be a non-negative integer")
+    if value.isascii() and value.isdecimal():
+        try:
+            return int(value), None
+        except ValueError:
+            pass
+    return None, _("afterSequence must be a non-negative integer")
+
+
 def run_server(
     *,
     host: str,