""" 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)})}