@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/_core/rule_contract.py

@@ -59,6 +59,8 @@ _FORM_ACTION_KEY_MAP = {
     "visible": "Visible",
     "expression": "Expression",
     "ret": "RET",
+    "events": "events",
+    "addevents": "addEvents",
     "seq": "Seq",
     "fieldname": "FieldName",
     "displaystyles": "DisplayStyles",
@@ -70,6 +72,7 @@ _BIZ_ACTION_KEY_MAP = {
     "actiontype": "ActionType", "description": "Description",
     "expression": "Expression", "fieldname": "FieldName",
     "ret": "RET", "seq": "Seq",
+    "events": "events", "addevents": "addEvents",
 }
 
 _ADVANCED_TAKE_VALUE_ACTIONS = frozenset({
@@ -86,35 +89,41 @@ def _single_casefold_value(source: dict, name: str):
 
 
 def _normalize_take_value_list(value, *, path, resolve_target=None):
-    if not isinstance(value, list) or len(value) != 1 or not isinstance(value[0], dict):
+    if not isinstance(value, list) or not value or not all(isinstance(item, dict) for item in value):
         raise ValueError(
-            f"RULE_ACTION_TAKE_VALUE_INVALID: {path} must contain exactly one mapping object"
+            f"RULE_ACTION_TAKE_VALUE_INVALID: {path} must contain one or more mapping objects"
         )
     key_map = {
         "targetfield": "TargetField", "srcfield": "SrcField",
         "targetfieldname": "TargetFieldName", "srcfieldname": "SrcFieldName",
         "onlyemptyrow": "OnlyEmptyRow",
     }
-    item = {"_Type_": "TakeValueId"}
-    for key, raw in value[0].items():
-        canonical = key_map.get(str(key).casefold(), key)
-        if canonical == "_Type_":
-            continue
-        compiled = copy.deepcopy(raw)
-        if resolve_target and isinstance(compiled, str):
-            compiled = resolve_target(compiled)
-        item[canonical] = compiled
     required = (
         ("TargetField", "SrcField")
         if path == "Expression"
         else ("TargetFieldName", "SrcFieldName")
     )
-    missing = [key for key in required if not str(item.get(key) or "").strip()]
-    if missing:
-        raise ValueError(
-            f"RULE_ACTION_TAKE_VALUE_INVALID: {path} missing {missing}"
-        )
-    return [item]
+    normalized = []
+    targets = set()
+    for index, mapping in enumerate(value):
+        item = {"_Type_": "TakeValueId"}
+        for key, raw in mapping.items():
+            canonical = key_map.get(str(key).casefold(), key)
+            if canonical == "_Type_":
+                continue
+            compiled = copy.deepcopy(raw)
+            if resolve_target and isinstance(compiled, str):
+                compiled = resolve_target(compiled)
+            item[canonical] = compiled
+        missing = [key for key in required if not str(item.get(key) or "").strip()]
+        if missing:
+            raise ValueError(f"RULE_ACTION_TAKE_VALUE_INVALID: {path}[{index}] missing {missing}")
+        target = str(item[required[0]]).strip()
+        if target in targets:
+            raise ValueError(f"RULE_ACTION_TAKE_VALUE_DUPLICATE_TARGET: {path}[{index}] {target!r}")
+        targets.add(target)
+        normalized.append(item)
+    return normalized
 
 
 def normalize_biz_rule_action(
@@ -137,6 +146,14 @@ def normalize_biz_rule_action(
     if not action_type:
         raise ValueError("RULE_ACTION_TYPE_REQUIRED: bizRule ActionType is required")
     _validate_action_type(action_type)
+    events = normalized.pop("events", None)
+    add_events = normalized.pop("addEvents", None)
+    if events is not None and add_events is not None:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose events or addEvents")
+    if events is not None and "RET" in normalized:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose events or RET")
+    if add_events is not None and "RET" not in normalized:
+        raise ValueError(f"RULE_EVENT_BASE_RET_REQUIRED: {action_type} needs the current RET with addEvents")
     if action_type in _ADVANCED_TAKE_VALUE_ACTIONS:
         normalized["Expression"] = _normalize_take_value_list(
             normalized.get("Expression"), path="Expression", resolve_target=resolve_target
@@ -144,6 +161,8 @@ def normalize_biz_rule_action(
         normalized["FieldName"] = _normalize_take_value_list(
             normalized.get("FieldName"), path="FieldName", resolve_target=resolve_target
         )
+        if len(normalized["Expression"]) != len(normalized["FieldName"]):
+            raise ValueError("RULE_ACTION_TAKE_VALUE_LENGTH_MISMATCH: Expression and FieldName must align")
         if action_type == "TakeBaseProAction":
             normalized["_Type_"] = "TakeBasePropertyAction"
     elif action_type in {"FormulaAction", "ClearValueAction", "CallFieldChangeAction"}:
@@ -164,11 +183,16 @@ def normalize_biz_rule_action(
         normalized["Expression"] = expression.strip()
     default_ret = {
         "FormulaAction": 253, "ClearValueAction": 253,
+        "CallFieldChangeAction": 773,
         "TakeBaseProAction": 253, "SetEqutionAction": 1021,
         "FillQtyAction": 249,
     }.get(action_type)
     if default_ret is not None:
         normalized.setdefault("RET", default_ret)
+    if events is not None:
+        normalized["RET"] = select_action_events(action_type, events)
+    if add_events is not None:
+        normalized["RET"] = merge_action_events(action_type, normalized["RET"], add_events)
     normalized.setdefault("Seq", default_seq)
     if "RET" in normalized:
         validate_action_ret(action_type, normalized["RET"])
@@ -204,6 +228,14 @@ def normalize_form_rule_action(
             )
         normalized[canonical] = copy.deepcopy(value)
     normalized["ActionType"] = action_type
+    events = normalized.pop("events", None)
+    add_events = normalized.pop("addEvents", None)
+    if events is not None and add_events is not None:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose events or addEvents")
+    if events is not None and "RET" in normalized:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose events or RET")
+    if add_events is not None and "RET" not in normalized:
+        raise ValueError(f"RULE_EVENT_BASE_RET_REQUIRED: {action_type} needs the current RET with addEvents")
 
     raw_targets = normalized.pop("FieldKey", None)
     if raw_targets is not None:
@@ -431,12 +463,16 @@ def normalize_form_rule_action(
 
     if action_type in _TARGETED_FORM_ACTIONS:
         normalized.pop("FieldName", None)
-    if action_type == "SetRowStyleAction" and "RET" not in normalized:
+    if action_type == "SetRowStyleAction" and "RET" not in normalized and events is None:
         raise ValueError(
             "RULE_ACTION_RET_REQUIRED: SetRowStyleAction has report-specific event "
             "masks; pass the exact verified RET for the target report"
         )
     normalized.setdefault("RET", FORM_RULE_DEFAULT_RET)
+    if events is not None:
+        normalized["RET"] = select_action_events(action_type, events)
+    if add_events is not None:
+        normalized["RET"] = merge_action_events(action_type, normalized["RET"], add_events)
     normalized.setdefault("Seq", default_seq)
     validate_action_ret(action_type, normalized["RET"])
     return normalized
@@ -455,6 +491,22 @@ def _validate_action_type(action_type: str) -> None:
         )
 
 
+def runtime_action_warnings(rule_config: dict) -> list[dict]:
+    warnings = _EVENT_CONTRACT.get("runtimeWarnings") or {}
+    actions = normalize_rule_config(rule_config)
+    kinds = {
+        action.get("ActionType")
+        for branch in ("trueActions", "falseActions")
+        for action in (actions.get(branch) or [])
+        if isinstance(action, dict)
+    }
+    return [
+        {"actionType": kind, "message": warnings[kind]}
+        for kind in sorted(kinds)
+        if kind in warnings
+    ]
+
+
 def validate_action_ret(action_type: str, requested) -> None:
     if isinstance(requested, bool) or not isinstance(requested, int) or requested < 1:
         raise ValueError(
@@ -468,14 +520,43 @@ def validate_action_ret(action_type: str, requested) -> None:
             f"unknown bits {unknown_bits} outside legal union {legal_union}"
         )
     _validate_action_type(action_type)
-    masks = _EVENT_CONTRACT.get("actionMasks") or {}
-    support_mask = int(masks[action_type])
-    unsupported_bits = requested & ~support_mask
-    if unsupported_bits:
-        raise ValueError(
-            f"RULE_RET_UNSUPPORTED: {action_type}.RET={requested} includes bits "
-            f"{unsupported_bits} outside action support mask {support_mask}"
-        )
+
+
+def _event_mask(events) -> int:
+    if not isinstance(events, (list, tuple)) or not events:
+        raise ValueError("RULE_EVENTS_INVALID: provide a non-empty array of event names")
+    bits = {name: int(bit) for bit, name in _EVENT_CONTRACT["eventBits"].items()}
+    aliases = _EVENT_CONTRACT.get("eventAliases") or {}
+    aliases_by_casefold = {key.casefold(): value for key, value in aliases.items()}
+    canonical_by_casefold = {key.casefold(): key for key in bits}
+    selected = 0
+    for name in events:
+        if not isinstance(name, str):
+            raise ValueError("RULE_EVENTS_INVALID: event names must be strings")
+        supplied = name.strip()
+        canonical = (aliases.get(supplied)
+                     or aliases_by_casefold.get(supplied.casefold())
+                     or canonical_by_casefold.get(supplied.casefold())
+                     or supplied)
+        if canonical not in bits:
+            raise ValueError(f"RULE_EVENT_UNKNOWN: {name!r}; expected {sorted(bits)}")
+        selected |= bits[canonical]
+    return selected
+
+
+def select_action_events(action_type: str, events) -> int:
+    """Compile exactly the requested event timings for a new action."""
+    selected = _event_mask(events)
+    validate_action_ret(action_type, selected)
+    return selected
+
+
+def merge_action_events(action_type: str, current: int, events) -> int:
+    """Append named events without clearing existing or non-checkbox bits."""
+    validate_action_ret(action_type, current)
+    merged = current | _event_mask(events)
+    validate_action_ret(action_type, merged)
+    return merged
 
 
 def trigger_field_selectors(rule_config: dict) -> list[str]:

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/build_meta_order.py

@@ -93,6 +93,20 @@ def collect_ref_bill_targets(data: dict[str, Any]) -> set[str]:
     return targets
 
 
+def validate_ref_bill_owner(data):
+    """Reject the unsupported Base-form deferred writer before creating its shell."""
+    entities = data.get("entities") or []
+    if not any(entity.get("type") == "BaseEntity" for entity in entities if isinstance(entity, dict)):
+        return []
+    return [
+        "REF_BILL_OWNER_UNSUPPORTED: the current RefBillField writer requires a bill form; "
+        "resolve model/reference semantics before creating this BaseEntity (no automatic type substitution)"
+        for entity in entities if isinstance(entity, dict)
+        for field in entity.get("fields") or []
+        if isinstance(field, dict) and field.get("dataType") == "RefBillField"
+    ]
+
+
 def bind_ref_bill_ids(
     data: dict[str, Any],
     form_ids: dict[str, str],
@@ -330,23 +344,13 @@ def _infer_form_number(data: dict[str, Any], path: str, isv: str) -> str:
     return os.path.splitext(os.path.basename(path))[0].lower()
 
 
-def plan_build_waves(
+def collect_build_dependencies(
     artifact_files: list[str],
     *,
     manifest: dict[str, Any] | None = None,
     isv: str = "",
-) -> list[list[str]]:
-    """Return ordered waves of artifact paths; each wave can run concurrently.
-
-    Dependencies: artifact A depends on B when A references B's formNumber and
-    B is also in this batch. References to forms outside the batch are ignored
-    (assumed already on platform).
-    """
-    if not artifact_files:
-        return []
-    if len(artifact_files) == 1:
-        return [list(artifact_files)]
-
+) -> dict[str, set[str]]:
+    """Exact prerequisites within this batch, keyed by normalized artifact path."""
     norm_paths = [os.path.normpath(os.path.abspath(p)) for p in artifact_files]
     path_set = set(norm_paths)
     m_map = _manifest_path_to_form(manifest)
@@ -365,10 +369,7 @@ def plan_build_waves(
         form_to_path[fn] = p
         path_refs[p] = _collect_form_refs(data)
 
-    # in-degree among batch artifacts only
-    in_deg: dict[str, int] = {p: 0 for p in norm_paths}
-    dependents: dict[str, list[str]] = {p: [] for p in norm_paths}
-
+    dependencies = {p: set() for p in norm_paths}
     for p in norm_paths:
         own = path_form.get(p, "")
         for ref in path_refs.get(p) or set():
@@ -376,8 +377,20 @@ def plan_build_waves(
                 continue
             dep_path = form_to_path.get(ref)
             if dep_path and dep_path in path_set and dep_path != p:
-                in_deg[p] += 1
-                dependents[dep_path].append(p)
+                dependencies[p].add(dep_path)
+    return dependencies
+
+
+def plan_build_waves(artifact_files, *, manifest=None, isv="", dependencies=None):
+    """Topological waves; external references are resolved by the writer."""
+    graph = dependencies if dependencies is not None else collect_build_dependencies(
+        artifact_files, manifest=manifest, isv=isv)
+    norm_paths = list(graph)
+    in_deg = {path: len(parents) for path, parents in graph.items()}
+    dependents = {path: [] for path in graph}
+    for path, parents in graph.items():
+        for parent in parents:
+            dependents[parent].append(path)
 
     waves: list[list[str]] = []
     q = deque([p for p in norm_paths if in_deg[p] == 0])
@@ -406,6 +419,24 @@ def plan_build_waves(
     return waves
 
 
+def partition_build_wave(wave, dependencies, succeeded):
+    """Schedule only artifacts whose actual prerequisites verified successfully."""
+    ready, blocked = [], []
+    for path in wave:
+        missing = sorted(dependencies.get(path, set()) - succeeded)
+        if not missing:
+            ready.append(path)
+            continue
+        blocked.append({
+            "artifact": os.path.basename(path), "artifactPath": path,
+            "ok": False, "phase": "dependency", "writeAttempted": False,
+            "errorCode": "DEPENDENCY_FAILED", "blockedByArtifacts": missing,
+            "errors": ["Required artifacts did not verify successfully; this artifact was not written"],
+            "elapsed_sec": 0.0,
+        })
+    return ready, blocked
+
+
 def describe_build_plan(
     waves: list[list[str]],
     *,
@@ -425,33 +456,3 @@ def describe_build_plan(
                  for p in wave]
         lines.append(f"  wave {i}: {', '.join(names)}")
     return "\n".join(lines)
-
-
-def dependency_blocked_results(
-    waves: list[list[str]],
-    *,
-    failed_wave_index: int,
-) -> list[dict[str, Any]]:
-    """Return stable machine results for waves blocked by a failed prerequisite.
-
-    ``failed_wave_index`` is one-based, matching the CLI's wave labels.
-    """
-    blocked: list[dict[str, Any]] = []
-    for wave_index, wave in enumerate(waves, 1):
-        if wave_index <= failed_wave_index:
-            continue
-        for path in wave:
-            blocked.append(
-                {
-                    "artifact": os.path.basename(path),
-                    "ok": False,
-                    "phase": "dependency",
-                    "errorCode": "DEPENDENCY_WAVE_FAILED",
-                    "blockedByWave": failed_wave_index,
-                    "errors": [
-                        f"prerequisite wave {failed_wave_index} failed; artifact was not written"
-                    ],
-                    "elapsed_sec": 0.0,
-                }
-            )
-    return blocked