- New cp1-discovery-package-agent (ADR 0020): one package per reviewed run, every part hashed (sha256 over canonical JSON), with a manifest and a value scorecard. - Applications grouped CMDB -> tag -> resource group with a judged model fallback (ADR 0021): CMDB 0.7.0 carries ownership, dependency mapping 0.6.0 groups, report 0.9.0 shows them. - Critic 0.6.1 accepts the producers' enums; build_workflow.py refuses a consumer enum narrower than its producer's. - Code hooks, sub-agents and tests for the inventory, CMDB, dependency, planner and critic agents; the report and Well-Architected review agents; ADRs 0012-0021. - Workflow cases with value bars and run limits; run evaluation and usage collection scripts; the run context template and the field-by-field review for ADR 0016. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
66 lines
3.4 KiB
Python
66 lines
3.4 KiB
Python
"""A live run's coverage, computed in code from the critic's own listing of every resource in scope (ADR 0017).
|
|
|
|
The critic doesn't trust the planner's list: it lists the scope root again, with the same rules (app/scope.py), and
|
|
compares that with the findings and the planner's declared gaps. Only counts and the uncovered ids go to the model,
|
|
so a large estate doesn't fill its prompt.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Dict
|
|
|
|
from app import scope as sc
|
|
|
|
MAX_IDS = 200 # uncovered ids passed to the model; the count is always exact
|
|
|
|
|
|
def live_scope(payload: Dict[str, Any], call: sc.Call) -> Dict[str, Any]:
|
|
provider = payload["provider"]
|
|
items, refs, issues = sc.list_all(provider, call)
|
|
accounting = sc.account(provider, items)
|
|
key = (lambda i: i.lower()) if provider == "azure" else (lambda i: i) # ARM ids are case-insensitive
|
|
found = {key(str(f.get("scope_entry_id") or "")) for f in payload.get("findings") or []}
|
|
declared = {key(str(g.get("scope_entry_id") or "")) for g in payload.get("coverage_gaps") or []}
|
|
uncovered = [e["id"] for e in accounting["entries"] if key(e["id"]) not in found | declared]
|
|
return {
|
|
"listed": accounting["listed"],
|
|
"scope_entries": len(accounting["entries"]),
|
|
"folded": len(accounting["folded"]),
|
|
"structure": len(accounting["structure"]),
|
|
"covered": len(accounting["entries"]) - len(uncovered),
|
|
"coverage_gaps": uncovered[:MAX_IDS],
|
|
"coverage_gap_count": len(uncovered),
|
|
"listing_issues": issues,
|
|
"evidence_refs": refs,
|
|
}
|
|
|
|
|
|
def live_dependencies(payload: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Every dependency a finding records, against the graph (ADR 0019): an edge from the finding's record to the
|
|
target's record (or to the target itself, an external node), or a folded dependency. Computed in code, so the
|
|
model never re-derives it."""
|
|
provider = payload["provider"]
|
|
key = (lambda i: str(i or "").strip().rstrip("/").lower()) if provider == "azure" else \
|
|
(lambda i: str(i or "").strip().rstrip("/"))
|
|
records = {key(r.get("scope_entry_id")): r.get("canonical_id") for r in payload.get("records") or []}
|
|
edges = {(key(e.get("source")), key(e.get("target"))) for e in payload.get("edges") or []}
|
|
folded = {(key(f.get("source")), key(f.get("target"))) for f in payload.get("folded_dependencies") or []}
|
|
external = {key(n.get("id")) for n in payload.get("nodes") or [] if n.get("kind") == "external"}
|
|
recorded, as_edges, to_external, as_folded, missing = 0, 0, 0, 0, []
|
|
for finding in payload.get("findings") or []:
|
|
source = records.get(key(finding.get("scope_entry_id")))
|
|
for dep in finding.get("dependencies") or []:
|
|
rid = dep.get("id") if isinstance(dep, dict) else dep
|
|
if not rid or key(rid) == key(finding.get("scope_entry_id")):
|
|
continue
|
|
recorded += 1
|
|
target = records.get(key(rid)) or rid
|
|
if source and (key(source), key(target)) in edges:
|
|
as_edges += 1
|
|
to_external += key(target) in external
|
|
elif source and (key(source), key(rid)) in folded:
|
|
as_folded += 1
|
|
else:
|
|
missing.append(f"{finding.get('scope_entry_id')} -> {rid}")
|
|
return {"recorded": recorded, "edges": as_edges, "to_external_nodes": to_external, "folded": as_folded,
|
|
"missing": missing[:MAX_IDS], "missing_count": len(missing)}
|