The reference agent's subject, cloud solution architecture, as an agent in the operating model agent's pattern: the Execution engine (from orchestration_engine) and one Workflow in app/solution_architecture, built for the settings and provider bundle by assembly.workflow_for. Copied from gcp_solution_architecture_agent at 8b397cd without its own engine: its role files, Skills, provider bundle, ADRs, vocabulary, scripts and evaluation datasets. The image takes the engine from a named build context and installs Terraform. It is called through the Orchestration engine, and its files are what the operating model agent digests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
98 lines
3.7 KiB
Python
98 lines
3.7 KiB
Python
#!/usr/bin/env python3
|
|
"""Review the published Terraform modules a provider bundle's modules Skill uses.
|
|
|
|
For each module the Skill's examples call: the version pinned there, the latest in
|
|
the registry, and whether the latest still works with the pinned provider. For each
|
|
module the bundle lists under `terraform.modules.watch`, which could not be used
|
|
when last looked at: whether its latest version now can.
|
|
|
|
It reads the public registry and changes nothing. Raising a pinned version is a
|
|
change to the Skill's example, which `tests/test_iac_modules.py` then validates.
|
|
|
|
Usage: .venv/bin/python scripts/check-terraform-modules.py [provider]
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import re
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
|
|
from execution_engine.adk.runtime import ToolResult
|
|
from execution_engine.providers import load_provider
|
|
|
|
from app.solution_architecture.modules import ModuleLookup, admits, module_calls
|
|
|
|
_HCL = re.compile(r"^```hcl\n(.*?)^```", re.MULTILINE | re.DOTALL)
|
|
|
|
|
|
def _blocked(part: dict, pinned: dict[str, str]) -> list[str]:
|
|
"""The provider requirements of a module that the pinned versions do not meet."""
|
|
return [
|
|
f"{need.get('name')} {need.get('version')}"
|
|
for need in part.get("provider_dependencies") or []
|
|
if need.get("name") in pinned
|
|
and need.get("version")
|
|
and not admits(need["version"], pinned[need["name"]])
|
|
]
|
|
|
|
|
|
async def main(provider: str) -> int:
|
|
bundle = load_provider(provider)
|
|
if not bundle.terraform_modules_skill:
|
|
print(f"The {provider} bundle names no modules Skill.")
|
|
return 0
|
|
pinned = {name: pin["version"] for name, pin in bundle.terraform_providers.items()}
|
|
lookup = ModuleLookup(namespaces=bundle.terraform_module_namespaces, pinned=pinned)
|
|
skill = bundle.skills[bundle.terraform_modules_skill].path
|
|
|
|
used: dict[str, set[str]] = {}
|
|
for reference in sorted((skill / "references").glob("*.md")):
|
|
code = "\n".join(_HCL.findall(reference.read_text(encoding="utf-8")))
|
|
for call in module_calls({"main.tf": code}):
|
|
used.setdefault(call.source.split("//")[0], set()).add(call.version)
|
|
|
|
stale = 0
|
|
print(f"Pinned providers: {pinned}\n\nModules the Skill uses:")
|
|
for module, versions in sorted(used.items()):
|
|
data = await lookup._fetch(module, "")
|
|
if isinstance(data, ToolResult):
|
|
print(f" {module}: {data.message}")
|
|
continue
|
|
latest = str(data.get("version", "?"))
|
|
blocked = _blocked(data.get("root") or {}, pinned)
|
|
note = "up to date" if versions == {latest} else f"latest is {latest}"
|
|
if versions != {latest}:
|
|
stale += 1
|
|
if blocked:
|
|
note += f"; the latest needs {', '.join(blocked)}, so stay on the pin"
|
|
print(f" {module} {', '.join(sorted(versions))}: {note}")
|
|
|
|
print("\nModules that could not be used when last looked at:")
|
|
usable = 0
|
|
for name in bundle.terraform_modules_watch:
|
|
data = await lookup._fetch(name, "")
|
|
if isinstance(data, ToolResult):
|
|
print(f" {name}: {data.message}")
|
|
continue
|
|
blocked = _blocked(data.get("root") or {}, pinned)
|
|
if blocked:
|
|
print(f" {name} {data.get('version')}: still needs {', '.join(blocked)}")
|
|
else:
|
|
usable += 1
|
|
print(
|
|
f" {name} {data.get('version')}: NOW USABLE with the pinned provider"
|
|
)
|
|
print(
|
|
f"\n{stale} pinned module(s) have a newer version; {usable} watched "
|
|
"module(s) can now be used."
|
|
)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(asyncio.run(main(sys.argv[1] if len(sys.argv) > 1 else "gcp")))
|