procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/dto/process/fixtures/greet.dto.json

@@ -0,0 +1,317 @@
+{
+  "Id": "00000000-0000-0000-0000-000000000001",
+  "ParentId": null,
+  "Status": 1,
+  "Title": "Greet",
+  "Description": "demo",
+  "IsValid": true,
+  "Active": true,
+  "Timeout": 0,
+  "CurrentActionId": null,
+  "DebugMode": false,
+  "IsNotification": false,
+  "Variables": [
+    {
+      "Id": "00000000-0000-0000-0000-000000000002",
+      "ContextId": null,
+      "DataType": "0317bfee-b2f5-4bde-bfe8-121212121214",
+      "Type": 10,
+      "Name": "name",
+      "DefaultValue": null,
+      "IsList": false,
+      "IsError": false,
+      "IsRequired": true
+    },
+    {
+      "Id": "00000000-0000-0000-0000-000000000003",
+      "ContextId": null,
+      "DataType": "0317bfee-b2f5-4bde-bfe8-121212121214",
+      "Type": 30,
+      "Name": "greeting",
+      "DefaultValue": null,
+      "IsList": false,
+      "IsError": false,
+      "IsRequired": false
+    }
+  ],
+  "Actions": [
+    {
+      "Id": "00000000-0000-0000-0000-000000000005",
+      "FlowId": "00000000-0000-0000-0000-000000000001",
+      "TemplateId": "c0e32108-6e3e-4ab8-96bd-cd61be6edb33",
+      "ParentId": null,
+      "VariableErrorId": null,
+      "Status": 1,
+      "Category": "",
+      "ActionName": "Start",
+      "ActionTemplateName": "Start",
+      "Ports": [
+        {
+          "Id": "00000000-0000-0000-0000-000000000007",
+          "FlowId": "00000000-0000-0000-0000-000000000001",
+          "SourceId": "00000000-0000-0000-0000-000000000000",
+          "DestinationId": "00000000-0000-0000-0000-000000000005",
+          "Type": 0,
+          "State": 1,
+          "Data": {},
+          "Errors": {},
+          "Config": {}
+        },
+        {
+          "Id": "00000000-0000-0000-0000-000000000008",
+          "FlowId": "00000000-0000-0000-0000-000000000001",
+          "SourceId": "00000000-0000-0000-0000-000000000005",
+          "DestinationId": "00000000-0000-0000-0000-000000000004",
+          "Type": 0,
+          "State": 1,
+          "Data": {},
+          "Errors": {},
+          "Config": {}
+        }
+      ],
+      "Parameters": [],
+      "CustomData": {
+        "type": "square",
+        "name": "Start",
+        "icon": "icon-start",
+        "position": {
+          "x": 80.0,
+          "y": 80.0
+        },
+        "configuration": [
+          {
+            "id": "c0e32108-6e3e-4ab8-96bd-cd61be6edb35",
+            "label": "Details",
+            "orderId": 0,
+            "settings": []
+          },
+          {
+            "id": "c0e32108-6e3e-4ab8-96bd-cd61be6edb36",
+            "label": "Input & Output",
+            "orderId": 0,
+            "settings": []
+          }
+        ],
+        "inputPorts": 0,
+        "outputPorts": 1,
+        "wasDropped": true,
+        "areaSize": {
+          "width": 48,
+          "height": 48,
+          "x": 0,
+          "y": 0
+        }
+      },
+      "IsTestable": false,
+      "IsDisabled": false,
+      "BreakPoint": null,
+      "TestValues": null,
+      "ErrorMessage": "",
+      "Events": null
+    },
+    {
+      "Id": "00000000-0000-0000-0000-000000000004",
+      "FlowId": "00000000-0000-0000-0000-000000000001",
+      "TemplateId": "894e02d1-303d-4e52-9ef7-1b3198ee4b53",
+      "ParentId": null,
+      "VariableErrorId": null,
+      "Status": 1,
+      "Category": "",
+      "ActionName": "Concatenate",
+      "ActionTemplateName": "Concatenate",
+      "Ports": [
+        {
+          "Id": "00000000-0000-0000-0000-000000000009",
+          "FlowId": "00000000-0000-0000-0000-000000000001",
+          "SourceId": "00000000-0000-0000-0000-000000000004",
+          "DestinationId": "00000000-0000-0000-0000-000000000006",
+          "Type": 0,
+          "State": 1,
+          "Data": {},
+          "Errors": {},
+          "Config": {}
+        }
+      ],
+      "Parameters": [
+        {
+          "TabPropertyId": "797e45d8-da43-4412-bac4-a3cbdf961b37",
+          "Variable": [
+            {
+              "id": 0,
+              "variableId": "00000000-0000-0000-0000-000000000002",
+              "attribute": null
+            }
+          ],
+          "Value": "<%0%>"
+        },
+        {
+          "TabPropertyId": "117061e7-e531-4340-9cc1-da8f6e13633a",
+          "Variable": [],
+          "Value": " - processed"
+        },
+        {
+          "TabPropertyId": "9cdb4f28-e2e3-4933-ada8-1285f7f635f4",
+          "Variable": [
+            {
+              "id": 1,
+              "variableId": "00000000-0000-0000-0000-000000000003",
+              "attribute": null
+            }
+          ],
+          "Value": "<%1%>"
+        }
+      ],
+      "CustomData": {
+        "type": "square",
+        "name": "Concatenate",
+        "icon": "merge",
+        "position": {
+          "x": 240.0,
+          "y": 80.0
+        },
+        "configuration": [
+          {
+            "id": "5d932fcf-f1b8-41d6-ad8d-bdd9a1ab7504",
+            "label": "Configuration Tab",
+            "orderId": 0,
+            "settings": [
+              {
+                "id": "9cdb4f28-e2e3-4933-ada8-1285f7f635f4",
+                "dataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+                "label": "Result",
+                "type": "datatype",
+                "language": null,
+                "credentialsTemplateId": null,
+                "value": "00000000-0000-0000-0000-000000000003",
+                "options": null,
+                "isRequired": true,
+                "expects": "string",
+                "isList": false,
+                "direction": 3,
+                "rowId": 3,
+                "columnId": 0,
+                "columnSize": 0,
+                "tooltip": null,
+                "limits": null,
+                "dependencies": [],
+                "events": []
+              },
+              {
+                "id": "797e45d8-da43-4412-bac4-a3cbdf961b37",
+                "dataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+                "label": "Input String 1",
+                "type": "text",
+                "language": null,
+                "credentialsTemplateId": null,
+                "value": "00000000-0000-0000-0000-000000000002",
+                "options": null,
+                "isRequired": true,
+                "expects": "string",
+                "isList": false,
+                "direction": 1,
+                "rowId": 1,
+                "columnId": 0,
+                "columnSize": 0,
+                "tooltip": null,
+                "limits": null,
+                "dependencies": [],
+                "events": []
+              },
+              {
+                "id": "117061e7-e531-4340-9cc1-da8f6e13633a",
+                "dataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+                "label": "Input String 2",
+                "type": "text",
+                "language": null,
+                "credentialsTemplateId": null,
+                "value": " - processed",
+                "options": null,
+                "isRequired": true,
+                "expects": "string",
+                "isList": false,
+                "direction": 1,
+                "rowId": 2,
+                "columnId": 0,
+                "columnSize": 0,
+                "tooltip": null,
+                "limits": null,
+                "dependencies": [],
+                "events": []
+              }
+            ]
+          }
+        ],
+        "inputPorts": 1,
+        "outputPorts": 1,
+        "wasDropped": true,
+        "areaSize": {
+          "width": 48,
+          "height": 48,
+          "x": 0,
+          "y": 0
+        }
+      },
+      "IsTestable": true,
+      "IsDisabled": false,
+      "BreakPoint": null,
+      "TestValues": null,
+      "ErrorMessage": "",
+      "Events": null
+    },
+    {
+      "Id": "00000000-0000-0000-0000-000000000006",
+      "FlowId": "00000000-0000-0000-0000-000000000001",
+      "TemplateId": "c0e32108-6e3e-4ab8-96bd-cd61be6edb34",
+      "ParentId": null,
+      "VariableErrorId": null,
+      "Status": 1,
+      "Category": "",
+      "ActionName": "Stop",
+      "ActionTemplateName": "Stop",
+      "Ports": [],
+      "Parameters": [],
+      "CustomData": {
+        "type": "square",
+        "name": "Stop",
+        "icon": "icon-stop",
+        "position": {
+          "x": 400.0,
+          "y": 80.0
+        },
+        "configuration": [
+          {
+            "id": "c0e32108-6e3e-4ab8-96bd-cd61be6edb37",
+            "label": "Details",
+            "orderId": 0,
+            "settings": []
+          },
+          {
+            "id": "c0e32108-6e3e-4ab8-96bd-cd61be6edb38",
+            "label": "Input & Output",
+            "orderId": 0,
+            "settings": []
+          }
+        ],
+        "inputPorts": 1,
+        "outputPorts": 0,
+        "wasDropped": true,
+        "areaSize": {
+          "width": 48,
+          "height": 48,
+          "x": 0,
+          "y": 0
+        }
+      },
+      "IsTestable": false,
+      "IsDisabled": false,
+      "BreakPoint": null,
+      "TestValues": null,
+      "ErrorMessage": "",
+      "Events": null
+    }
+  ],
+  "Webhooks": [],
+  "CustomResponse": null,
+  "DataRetention": null,
+  "CanvasData": null
+}

procesio_cli/tools/procesio/dto/process/naming.py

@@ -0,0 +1,305 @@
+"""Deterministic, PURE naming for process actions and Decisional branches.
+
+Why this exists: an un-named action falls back to its generic template label
+("Node", "Call API"), so a canvas of a dozen script nodes is unreadable — the
+exact problem `rename-actions` fixes post-hoc. This derives a meaningful label
+from what the action is CONFIGURED to do, at BUILD time, so a freshly built or
+edited process arrives already legible. Likewise a Decisional/AI Decisional
+branch defaults to "Case 1/2/3…"; this labels each non-default case by its
+condition instead.
+
+Load-bearing rules:
+  * An explicit ``name`` on the action/branch ALWAYS wins; this only fills the
+    blank. On an edit the derived name is recomputed, so it always reflects the
+    CURRENT config (the "re-evaluate on edit" contract) — an explicit label the
+    user set stays put.
+  * A name is derived ONLY from config known at build time: a literal value, the
+    TEXT of a code template (its placeholders are filled at run time, the text is
+    not), a Query Store's SQL, or the NAME of the variable an action writes. A
+    param bound to a variable's VALUE is unknowable at build time, so it never
+    feeds a name — never a guess.
+  * A name is COSMETIC — every reference in a flow is by id (ports, Decisional
+    cases, parameter bindings) — so naming can only ever change a label, never
+    wiring.
+  * Decisional / AI Decisional ACTIONS keep their template label; their meaning
+    lives in the per-branch names (``derive_branch_name``).
+  * Everything here is pure and deterministic (no clock, no randomness): the
+    same config always yields the same names — required for golden tests and
+    for stable canvases across edits.
+"""
+from __future__ import annotations
+
+import re
+
+MAX_ACTION_NAME = 60
+MAX_BRANCH_NAME = 48
+
+
+# -- shared helpers -----------------------------------------------------------
+
+def _cap(text, limit=MAX_ACTION_NAME):
+    """Collapse whitespace, trim, and cap length with an ellipsis. Empty -> None."""
+    if not text:
+        return None
+    s = re.sub(r"\s+", " ", str(text)).strip()
+    if not s:
+        return None
+    return s if len(s) <= limit else s[: limit - 1].rstrip() + "…"
+
+
+def _literal(params, *labels):
+    """A param's LITERAL value by any label (case-insensitive), or None.
+
+    A binding to a variable/template/credential ({"var"|"template"|"credential"})
+    is not a literal — it cannot be summarized at build time — so it yields None.
+    A bare scalar or {"value": x} yields the scalar.
+    """
+    low = {str(k).strip().lower(): v for k, v in (params or {}).items()}
+    for lb in labels:
+        if lb.strip().lower() in low:
+            v = low[lb.strip().lower()]
+            if isinstance(v, dict):
+                if "value" in v and len(v) == 1:
+                    return v["value"]
+                return None
+            if isinstance(v, (list, tuple)):
+                return None
+            return v
+    return None
+
+
+def _template_text(params, *labels):
+    """The source text of a param authored as a code template ({"template": text, ...})."""
+    low = {str(k).strip().lower(): v for k, v in (params or {}).items()}
+    for lb in labels:
+        v = low.get(lb.strip().lower())
+        if isinstance(v, dict) and isinstance(v.get("template"), str):
+            return v["template"]
+    return None
+
+
+def _var_name(params, *labels):
+    """The variable NAME a param is bound to ({"var": name}), or None."""
+    low = {str(k).strip().lower(): v for k, v in (params or {}).items()}
+    for lb in labels:
+        v = low.get(lb.strip().lower())
+        if isinstance(v, dict) and isinstance(v.get("var"), str):
+            return v["var"]
+    return None
+
+
+# -- action names -------------------------------------------------------------
+
+def _short_endpoint(url):
+    """The path of a URL (query stripped), or its host if there is no path."""
+    s = str(url).strip()
+    m = re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://([^/?#]+)(/[^?#]*)?", s)
+    if m:
+        host, path = m.group(1), m.group(2)
+        if path and path != "/":
+            return path.rstrip("/") or path
+        return host
+    # not an absolute URL: take the part before any query, first line only
+    return s.split("?", 1)[0].splitlines()[0].strip() or None
+
+
+_SQL_VERB = re.compile(r"^\s*(?:--[^\n]*\n|/\*.*?\*/|\s)*"
+                       r"(SELECT|INSERT|UPDATE|DELETE|MERGE|EXEC(?:UTE)?|WITH|CREATE|DROP|ALTER|TRUNCATE)",
+                       re.IGNORECASE | re.DOTALL)
+_SQL_TABLE = re.compile(r"\b(?:FROM|INTO|UPDATE|JOIN|TABLE)\s+"
+                        r"[\[\"`]?([A-Za-z_][\w.$]*)", re.IGNORECASE)
+
+
+def _sql_summary(query):
+    """"SELECT clients" from a literal SQL string; verb alone if no table found."""
+    q = str(query)
+    mv = _SQL_VERB.search(q)
+    if not mv:
+        return None
+    verb = mv.group(1).upper().replace("EXECUTE", "EXEC")
+    mt = _SQL_TABLE.search(q)
+    return f"{verb} {mt.group(1)}" if mt else verb
+
+
+_DS_REF = re.compile(r"\{\{ds:([^}]+)\}\}")
+_QS_VERB = re.compile(r"^\s*(?:--[^\n]*\n|/\*.*?\*/|\s)*(SELECT|WITH|INSERT|REPLACE|UPDATE|DELETE|MERGE)\b",
+                      re.IGNORECASE | re.DOTALL)
+_QS_WORD = {"SELECT": "Read", "WITH": "Read", "INSERT": "Save to", "REPLACE": "Save to",
+            "UPDATE": "Update", "DELETE": "Delete from", "MERGE": "Merge into"}
+
+
+def _query_store_summary(sql):
+    """"Read OMN Units" / "Update OMN Leads" from a Query Store statement.
+
+    Query Store SQL names its data stores as {{ds:Store Name}} placeholders; that name is
+    what a reader of the canvas recognises, so it wins over a raw table token. A statement
+    over several stores reads "Read A + 2 more"."""
+    q = str(sql or "")
+    m = _QS_VERB.search(q)
+    if not m:
+        return None
+    word = _QS_WORD[m.group(1).upper()]
+    stores = []
+    for st in _DS_REF.findall(q):
+        st = st.strip()
+        if st and st not in stores:
+            stores.append(st)
+    if not stores:
+        mt = _SQL_TABLE.search(q)
+        stores = [mt.group(1)] if mt else []
+    if not stores:
+        return word.split()[0]
+    return word + " " + stores[0] + (f" + {len(stores) - 1} more" if len(stores) > 1 else "")
+
+
+def _leading_comment(code):
+    """The first line of code if it is a comment (// # /* … */), else None.
+
+    A leading comment is a cheap, deterministic way for the author to name a
+    Node ("// resolve the invoice period"); absent one there is nothing to
+    summarize, so the Node keeps its template label.
+    """
+    for raw in str(code).splitlines():
+        line = raw.strip()
+        if not line:
+            continue
+        if line.startswith("//"):
+            return line[2:].strip() or None
+        if line.startswith("#"):
+            return line.lstrip("#").strip() or None
+        if line.startswith("/*"):
+            return line[2:].split("*/", 1)[0].strip() or None
+        return None  # first real line is code, not a comment
+    return None
+
+
+def derive_action_name(spec, template_name):
+    """A meaningful name for an action from its LITERAL config, or None.
+
+    None means "nothing better than the template label" — the caller keeps
+    ``template_name``. Only high-value templates are enriched; everything else
+    (whose template label is already descriptive: "Send Mail", "Download File")
+    returns None by design.
+    """
+    tn = (template_name or "").strip().lower()
+    params = spec.get("params") or {}
+
+    if tn in ("call api", "curl"):
+        verb = _literal(params, "Verb", "Method")
+        endpoint = _literal(params, "Endpoint", "URL", "Url")
+        if endpoint:
+            path = _short_endpoint(endpoint)
+            if path:
+                return _cap(f"{str(verb).upper()} {path}" if verb else path)
+        return None
+
+    if tn in ("for each", "foreach"):
+        lst = _var_name(params, "For Each Item", "In List")
+        return _cap(f"For each {lst}") if lst else None
+
+    if tn == "node":
+        # the author's leading comment names it best; otherwise say what it produces
+        code = _literal(params, "Code") or _template_text(params, "Code")
+        named = _leading_comment(code) if code else None
+        if named:
+            return _cap(named)
+        out = _var_name(params, "Single Result", "List Result")
+        return _cap(f"Compute {out}") if out else None
+
+    if tn == "query store":
+        qs = spec.get("queryStore") if isinstance(spec.get("queryStore"), dict) else {}
+        summ = _query_store_summary(qs.get("sql") or _literal(params, "Query", "SQL") or "")
+        return _cap(summ) if summ else None
+
+    if tn in ("execute query", "execute command"):
+        summ = _sql_summary(_literal(params, "Query", "Command") or "")
+        return _cap(summ) if summ else None
+
+    if tn == "generate document":
+        fn = _literal(params, "File Name", "FileName")
+        return _cap(f"Generate {fn}") if fn else None
+
+    return None
+
+
+def disambiguate(entries):
+    """Make AUTO-derived names unique within a flow. Returns {key: final_name}.
+
+    ``entries`` is an ordered list of (key, name, is_auto). Explicit names
+    (is_auto False) are kept verbatim — a user may deliberately reuse a label.
+    Auto names that collide with any name already taken get a " 2", " 3"… suffix
+    in flow order, so three un-named Call APIs read "GET /a", "POST /b", etc. and
+    two identical ones read "GET /x", "GET /x 2".
+    """
+    used = {name for _, name, is_auto in entries if not is_auto and name}
+    final = {}
+    for key, name, is_auto in entries:
+        if not is_auto:
+            final[key] = name
+            continue
+        cand, n = name, 1
+        while cand in used:
+            n += 1
+            cand = f"{name} {n}"
+        used.add(cand)
+        final[key] = cand
+    return final
+
+
+# -- branch (Decisional case) names -------------------------------------------
+
+_OP_SYMBOL = {
+    "EQUALS": "=", "DOES_NOT_EQUAL": "≠",
+    "GREATER_THAN": ">", "GREATER_THAN_OR_EQUAL_TO": "≥",
+    "LESS_THAN": "<", "LESS_THAN_OR_EQUAL_TO": "≤",
+    "CONTAINS": "contains", "DOES_NOT_CONTAIN": "doesn't contain",
+    "BELONGS": "in", "DOES_NOT_BELONG": "not in",
+}
+# unary operators: the right operand is ignored, so render the left alone
+_OP_UNARY = {
+    "IS_EMPTY": "{x} empty", "IS_NOT_EMPTY": "{x} present",
+    "IS_TRUE": "{x}", "IS_FALSE": "not {x}",
+}
+
+
+def _operand_label(op):
+    """A readable token for a decisional operand (variable name, path, or literal)."""
+    if isinstance(op, dict):
+        if isinstance(op.get("var"), str):
+            path = op.get("path")
+            return op["var"] + ("." + ".".join(str(p) for p in path) if path else "")
+        if "value" in op:
+            op = op["value"]
+        else:
+            return ""
+    return "" if op is None else str(op)
+
+
+def _condition_label(cond):
+    left = _operand_label(cond.get("left"))
+    op = (cond.get("op") or "").strip().upper()
+    if op in _OP_UNARY:
+        return _OP_UNARY[op].format(x=left).strip()
+    sym = _OP_SYMBOL.get(op) or op.replace("_", " ").lower()
+    right = _operand_label(cond.get("right", ""))
+    return f"{left} {sym} {right}".strip()
+
+
+def derive_branch_name(branch, is_ai):
+    """A label for a non-default Decisional case from its condition, or None.
+
+    AI Decisional: the case ``condition`` is already a plain-English sentence, so
+    a capped form of it IS the name. Rule-based Decisional: join each ``when``
+    clause ("amount > 1000 and status = paid"). None -> caller falls back to
+    "Case N".
+    """
+    if is_ai:
+        return _cap(branch.get("condition") or "", MAX_BRANCH_NAME)
+    whens = branch.get("when") or []
+    parts = [p for p in (_condition_label(c) for c in whens) if p]
+    if not parts:
+        return None
+    tail = whens[1:]
+    joiner = " or " if tail and all(
+        (c.get("logic", "and") or "and").strip().lower() == "or" for c in tail) else " and "
+    return _cap(joiner.join(parts), MAX_BRANCH_NAME)