auto / lambdas /codegen_handler.py
rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98
Raw History Blame Contribute Delete
11.8 kB
"""
ALLI Code Generator Service (alli-codegen) -- Phase 7 Facade
Synthesizes deterministic, standalone, PEP 8-compliant Python scripts,
requirements.txt, and Dockerfiles directly from validated visual graphs.
"""
from collections import defaultdict
import json
import re
from typing import Any, Dict, List, Optional
from language_core.codegen_contracts import (
BANNED_IMPORTS,
PINNED_PACKAGE_VERSIONS,
STANDARD_LIBS,
format_literal,
sanitize_identifier,
)
from language_core.execution_session import compute_graph_hash
from language_core.node_schema import default_registry, get_effective_node_schema
from lambdas.codegen.assembler import assemble_python_artifacts
from lambdas.codegen.context import (
CodegenContext,
NodeCodegenCtx,
build_empty_workflow_response,
compute_topological_order,
run_preflight_codegen_checks,
)
from lambdas.codegen.emitters_control_oop import (
emit_control_and_functions_node,
emit_module_and_fallback_node,
emit_string_and_oop_node,
)
from lambdas.codegen.emitters_core import (
emit_category_node,
emit_essentials_node,
emit_values_math_io_node,
)
from lambdas.codegen.emitters_files_data import (
emit_collection_node,
emit_file_and_structured_node,
)
# Backwards compatible internal aliases
_sanitize_identifier = sanitize_identifier
_format_literal = format_literal
EMITTER_PIPELINE = (
emit_category_node,
emit_essentials_node,
emit_values_math_io_node,
emit_file_and_structured_node,
emit_control_and_functions_node,
emit_collection_node,
emit_string_and_oop_node,
emit_module_and_fallback_node,
)
def _register_node_outputs(nctx: NodeCodegenCtx, node_var: Optional[str]) -> None:
if not node_var:
return
ovm = nctx.cg.output_var_map
nid = nctx.node_id
ovm[nid] = node_var
for port in ("result", "out", "val", "value", "out_val"):
ovm[f"{nid}:{port}"] = node_var
if nctx.schema and hasattr(nctx.schema, "outputs"):
for out in nctx.schema.outputs:
out_id = getattr(out, "id", None) or (out.get("id") if isinstance(out, dict) else None)
if out_id and f"{nid}:{out_id}" not in ovm:
ovm[f"{nid}:{out_id}"] = node_var
nctx.cg.last_return_var = node_var
def generate_code_logic(
nodes: Optional[List[Dict[str, Any]]] = None,
edges: Optional[List[Dict[str, Any]]] = None,
execution_order: Optional[List[str]] = None,
graph_name: str = "alli_workflow",
dependencies: Optional[List[str]] = None,
graph: Optional[Dict[str, Any]] = None,
validate: bool = True,
strict_validation: bool = False,
pin_exact: bool = True,
) -> Dict[str, Any]:
"""Authoritative Python code generation engine (Phase 7)."""
from language_core.workflow_migration import migrate_workflow
if isinstance(nodes, dict) and "nodes" in nodes and graph is None:
graph, nodes = nodes, None
if graph and isinstance(graph, dict):
graph = migrate_workflow(graph)
raw_nodes = graph.get("nodes") or []
raw_edges = graph.get("edges") if graph.get("edges") is not None else (graph.get("connections") or [])
name = graph.get("name") or graph_name or "alli_workflow"
deps = graph.get("dependencies") or dependencies or []
graph_obj = graph
else:
migrated = migrate_workflow({"nodes": nodes or [], "edges": edges or []})
raw_nodes = migrated.get("nodes") or []
raw_edges = migrated.get("edges") or []
name = graph_name or "alli_workflow"
deps = dependencies or []
graph_obj = {"name": name, "nodes": raw_nodes, "edges": raw_edges, "dependencies": deps}
clean_name = sanitize_identifier(name.lower().replace(" ", "_"), "alli_workflow")
clean_filename = f"{clean_name}.py"
graph_fingerprint = compute_graph_hash(graph_obj)
if not raw_nodes:
return build_empty_workflow_response(name, clean_filename, graph_fingerprint)
diagnostics = run_preflight_codegen_checks(raw_nodes, graph_obj, validate, strict_validation)
blocking = [d for d in diagnostics if d.get("severity") == "error"]
if blocking:
return {
"success": False, "python_code": "", "code": "", "requirements_txt": "", "dockerfile": "",
"filename": clean_filename, "dependencies": [], "execution_order": [],
"diagnostics": diagnostics, "source_map": [], "generator_version": "1.0.0",
"graph_fingerprint": graph_fingerprint,
"metadata": {"valid": False, "error_count": len(blocking), "ast_valid": False, "node_count": len(raw_nodes)},
}
filtered_nodes = [
n for n in raw_nodes
if str(n.get("node_type") or n.get("type") or n.get("data", {}).get("node_type") or "")
not in ("system.workflow_group", "workflow_group", "workflowGroup")
]
filtered_edges = [
e for e in raw_edges
if not str(e.get("source", "")).startswith("group_") and not str(e.get("target", "")).startswith("group_")
]
node_map = {str(n["id"]): n for n in filtered_nodes if n.get("id")}
ordered_ids, has_cycle = compute_topological_order(node_map, filtered_edges, execution_order)
if has_cycle:
return {
"success": False, "python_code": "", "requirements_txt": "", "dockerfile": "",
"filename": clean_filename, "dependencies": [], "execution_order": [],
"diagnostics": [{"code": "DAG-001", "severity": "error", "message": "Cycle detected during code generation topological sequencing.", "fix_suggestion": "Remove circular feedback wires between procedural nodes."}],
"source_map": [], "generator_version": "1.0.0", "graph_fingerprint": graph_fingerprint,
"metadata": {"valid": False, "has_cycles": True},
}
incoming_edges_map: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
for edge in filtered_edges:
incoming_edges_map[str(edge.get("target") or edge.get("to_node") or "")].append(edge)
cg = CodegenContext(diagnostics=diagnostics)
for dep in deps:
clean_dep = str(dep).strip()
if clean_dep and clean_dep not in STANDARD_LIBS and clean_dep not in BANNED_IMPORTS:
cg.discovered_requirements.add(clean_dep)
def _emit_single_node(
node_id: str,
extra_indent: int = 0,
incoming_override: Optional[List[Dict[str, Any]]] = None,
build_only: bool = False,
) -> Tuple[Optional[NodeCodegenCtx], Optional[str]]:
node = node_map.get(node_id)
if not node:
return None, None
raw_type = str(node.get("node_type") or node.get("type") or node.get("data", {}).get("node_type") or node.get("data", {}).get("nodeType") or "").strip().lower()
data = node.get("data", {}) or {}
params = dict(node.get("parameters") if isinstance(node.get("parameters"), dict) else {})
node_inputs = node.get("inputs") if isinstance(node.get("inputs"), dict) else (data.get("inputs") if isinstance(data.get("inputs"), dict) else {})
label = str(data.get("label") or node.get("label") or raw_type or node_id)
clean_lbl = re.sub(r"_+", "_", re.sub(r"[^a-zA-Z0-9_]", "_", label.lower()).strip("_"))
if str(node_id).startswith("alli_primitive_") or len(str(node_id)) > 20:
safe_id = f"{clean_lbl}_{cg.step_counter}" if (clean_lbl and not clean_lbl[0].isdigit() and len(clean_lbl) <= 24) else f"step_{cg.step_counter}"
else:
safe_id = sanitize_identifier(node_id.replace("-", "_"), f"node_{cg.step_counter}")
schema = get_effective_node_schema(raw_type)
cap_states = (
(schema.capability_states if schema and hasattr(schema, "capability_states") else None)
or (schema.verification.capability_states if schema and getattr(schema, "verification", None) else None)
or data.get("capability_states") or params.get("capability_states") or node.get("capability_states")
or (data.get("verification") or {}).get("capability_states")
)
if cap_states and cap_states.get("codegen_supported") is False:
cg.diagnostics.append({"code": "CODEGEN_UNSUPPORTED", "severity": "error", "message": f"Code generation is unsupported for node '{label}' ({node_id}) of type '{raw_type}'.", "node_id": node_id})
if schema and getattr(schema, "codegen", None):
for imp in schema.codegen.imports:
clean_imp = str(imp).strip()
if clean_imp not in BANNED_IMPORTS:
cg.discovered_modules.add(clean_imp)
if clean_imp not in STANDARD_LIBS:
cg.discovered_requirements.add(clean_imp)
for req in schema.codegen.requirements:
clean_req = str(req).strip()
if clean_req not in STANDARD_LIBS and clean_req not in BANNED_IMPORTS:
cg.discovered_requirements.add(clean_req)
nctx = NodeCodegenCtx(
node_id=node_id, raw_type=raw_type, label=label, clean_lbl=clean_lbl,
safe_id=safe_id, params=params, data=data, node_inputs=node_inputs,
incoming=incoming_override if incoming_override is not None else incoming_edges_map.get(node_id, []),
schema=schema, cg=cg,
)
if build_only:
return nctx, None
start_line = len(cg.code_body_lines) + 1
prev_len = len(cg.code_body_lines)
cg.code_body_lines.append(f" # Step {cg.step_counter}: [{label}]")
node_var: Optional[str] = None
for emit_fn in EMITTER_PIPELINE:
handled, node_var = emit_fn(nctx)
if handled:
break
_register_node_outputs(nctx, node_var)
if extra_indent > 0:
pad = " " * extra_indent
for li in range(prev_len, len(cg.code_body_lines)):
if cg.code_body_lines[li].strip():
cg.code_body_lines[li] = pad + cg.code_body_lines[li]
cg.source_map.append({"node_id": node_id, "line_start": start_line, "line_end": len(cg.code_body_lines), "target_var": node_var, "statement_label": label})
cg.step_counter += 1
return nctx, node_var
from lambdas.codegen.scoped_blocks import emit_workflow_with_scopes
if not emit_workflow_with_scopes(cg, ordered_ids, node_map, filtered_edges, incoming_edges_map, _emit_single_node, _register_node_outputs):
for node_id in ordered_ids:
_emit_single_node(node_id)
return assemble_python_artifacts(cg, name, clean_filename, ordered_ids, graph_fingerprint, pin_exact)
def handler(event: Dict[str, Any], context: Any = None) -> Dict[str, Any]:
"""AWS Lambda entrypoint for alli-codegen function."""
try:
body_raw = event.get("body", "{}")
body = json.loads(body_raw) if isinstance(body_raw, str) else body_raw
result = generate_code_logic(
nodes=body.get("nodes", []),
edges=body.get("edges", []),
execution_order=body.get("execution_order"),
graph_name=body.get("name", "alli_workflow"),
dependencies=body.get("dependencies", []),
strict_validation=bool(body.get("strict_validation", False)),
pin_exact=bool(body.get("pin_exact", True)),
)
return {"statusCode": 200, "headers": {"Content-Type": "application/json", "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "POST, OPTIONS"}, "body": json.dumps(result)}
except Exception as err:
return {"statusCode": 500, "headers": {"Content-Type": "application/json", "Access-Control-Allow-Origin": "*"}, "body": json.dumps({"error": str(err)})}