programgarden 1.29.4__tar.gz → 1.30.0__tar.gz

{programgarden-1.29.4 → programgarden-1.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.29.4
+Version: 1.30.0
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -16,7 +16,7 @@ Requires-Dist: croniter (>=6.0.0,<7.0.0)
 Requires-Dist: litellm (>=1.40.0)
 Requires-Dist: lxml (>=6.0.2,<7.0.0)
 Requires-Dist: programgarden-community (>=1.13.11,<2.0.0)
-Requires-Dist: programgarden-core (>=1.21.0,<2.0.0)
+Requires-Dist: programgarden-core (>=1.22.0,<2.0.0)
 Requires-Dist: programgarden-finance (>=1.6.14,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)

{programgarden-1.29.4 → programgarden-1.30.0}/programgarden/executor.py

@@ -1125,10 +1125,22 @@ def _pick_split_array(upstream: Dict[str, Any], *, source: str) -> List[Any]:
     if len(candidates) == 1:
         return upstream[candidates[0]]
     if not candidates:
+        # ⑰ Diagnostic: a singular alias (value → values, item → items) present
+        # where the plural array port was meant is a common wrong-key mistake;
+        # surface it in the error so the fix is obvious (report-only — resolution
+        # is unchanged, the two ports legitimately co-exist).
+        _alias_hint = ""
+        for _sing, _plur in (("value", "values"), ("item", "items")):
+            if _sing in upstream and _plur not in upstream:
+                _alias_hint = (
+                    f" Upstream has '{_sing}' (singular) but no '{_plur}' (array) "
+                    f"— did you mean '{_plur}'?"
+                )
+                break
         raise RuntimeError(
             f"SplitNode has no array to split: upstream ({source}) exposes no "
-            f"array output among {_SPLIT_ARRAY_KEYS}. Bind split.array explicitly "
-            "(e.g. array: '{{ nodes.<id>.held_symbols }}') or wire an "
+            f"array output among {_SPLIT_ARRAY_KEYS}.{_alias_hint} Bind split.array "
+            "explicitly (e.g. array: '{{ nodes.<id>.held_symbols }}') or wire an "
             "array-producing node upstream."
         )
     raise RuntimeError(
@@ -1548,10 +1560,26 @@ class ScheduleNodeExecutor(NodeExecutorBase):
             context.log("debug", f"Scheduler already running for {node_id}, skip", node_id)
             return {"trigger": True}
         
-        cron_expr = config.get("cron", "*/5 * * * *")
+        # ⑭ cron is required — NO silent "*/5 * * * *" fallback. A missing cron
+        # used to make the schedule quietly run every 5 minutes ("looks fine,
+        # behaves differently"). Fail loudly instead so the real cause surfaces.
+        cron_expr = config.get("cron")
+        if not isinstance(cron_expr, str) or not cron_expr.strip():
+            context.log(
+                "error",
+                "ScheduleNode requires a 'cron' expression; there is no default schedule fallback",
+                node_id,
+            )
+            raise ValueError(
+                f"ScheduleNode '{node_id}' requires a 'cron' expression; there is no "
+                f"default schedule fallback. Set cron explicitly, e.g. '*/5 * * * *' "
+                f"(every 5 min) or '30 9 * * 1-5' (09:30 weekdays). Keys like "
+                f"'mode'/'schedule' are not read by this node."
+            )
+        cron_expr = cron_expr.strip()
         tz_name = config.get("timezone", "America/New_York")
         enabled = config.get("enabled", True)
-        count = config.get("count", 1000)  # 최대 반복 횟수 (M-6: 기본값 축소)
+        count = config.get("count", 1000)  # 최대 반복 횟수 (M-6: 기본값 축소; 모델 필드로 편입)
         max_duration_hours = config.get("max_duration_hours", 24.0)
         
         if not enabled:
@@ -10594,7 +10622,7 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             except (ValueError, _json.JSONDecodeError):
                 pass
 
-        # 우선순위: config.symbol > input.symbol
+        # 우선순위: config.symbol > input.symbol > config.symbols (수동 목록 폴백)
         if config_symbol:
             symbols_raw = [config_symbol] if isinstance(config_symbol, dict) else []
             context.log("debug", f"Using config.symbol: {config_symbol}", node_id)
@@ -10602,7 +10630,23 @@ class HistoricalDataNodeExecutor(NodeExecutorBase):
             symbols_raw = [input_symbol] if isinstance(input_symbol, dict) else []
             context.log("debug", f"Using input port symbol: {input_symbol}", node_id)
         else:
-            symbols_raw = []
+            # 마지막 폴백: config.symbols (복수 리터럴 목록) — MarketDataNodeExecutor 의
+            # config_symbols 폴백과 대칭. 상류 배열 입력은 메인 루프 auto-iterate 가
+            # 단수 input.symbol 로 풀어 위 분기에서 소화되므로, 여기 도달하는 건
+            # 리터럴 목록뿐이라 N² 재조회 우려가 없다. deep_validate 픽스처는 이미
+            # _config_symbols() 로 plural 을 읽어 라이브만 조용히 무시하던 비대칭이었다
+            # (실측: code-node 예제 87~93 이 심볼 3개를 적고도 빈 ohlcv 로 사망).
+            config_symbols = config.get("symbols")
+            if isinstance(config_symbols, list):
+                symbols_raw = [e for e in config_symbols if isinstance(e, (dict, str))]
+                if symbols_raw:
+                    context.log(
+                        "debug",
+                        f"Using config.symbols list: {len(symbols_raw)} entries",
+                        node_id,
+                    )
+            else:
+                symbols_raw = []
         
         # symbols 정규화: [{exchange, symbol}] → 문자열 리스트 + exchange 정보 보존
         symbols = []
@@ -12386,7 +12430,21 @@ class PositionSizingNodeExecutor(NodeExecutorBase):
         price_data = evaluated.get("price_data") or evaluated.get("prices") or evaluated.get("market_data") or {}
         
         # 설정 추출
-        method = evaluated.get("method", "fixed_percent")
+        # ⑰ method is required — NO silent "fixed_percent" fallback. The old
+        # default quietly confirmed a hallucinated key (e.g. size_type:"fixed"
+        # left method unset → sized as fixed_percent). Fail loudly instead.
+        method = evaluated.get("method")
+        if not method:
+            context.log(
+                "error",
+                "PositionSizingNode requires 'method'; there is no default fallback",
+                node_id,
+            )
+            raise ValueError(
+                f"PositionSizingNode '{node_id}' requires 'method' (one of "
+                f"fixed_percent, fixed_amount, fixed_quantity, kelly, atr_based); "
+                f"there is no default. A key like 'size_type' is not read by this node."
+            )
         max_percent = float(evaluated.get("max_percent", 10.0))
         fixed_amount = evaluated.get("fixed_amount")
         fixed_quantity = int(evaluated.get("fixed_quantity", 1))

{programgarden-1.29.4 → programgarden-1.30.0}/programgarden/semantic_rules.py

@@ -7,8 +7,8 @@ workflows that are still *semantically* wrong or *unsafe* — they validate
 *executability*, never *intent* or *safety*.
 
 The four ground-truth anti-patterns (verified against the canonical example
-workflows shipped in ``programgarden/examples/workflows`` and the live node
-registry):
+corpus — maintained internally since the 2026-08 privatization — and the live
+node registry):
 
   * **R1 — order quantity bound to an AIAgent response.** An AIAgent
     sentiment/decision output wired straight into an order quantity risks a
@@ -27,6 +27,15 @@ registry):
     Always trades the same size regardless of balance/risk. (Advisory.)
   * **R4 — order node carrying ``paper_trading``.** That field is a *broker*
     field; on an order node it is silently ignored. (Advisory.)
+  * **R5 — unknown node config key.** A key that is not in the node's
+    ``get_field_schema()`` nor its declared model fields. ``BaseNode`` sets
+    ``extra="allow"`` so Pydantic accepts it, and the executor never reads it —
+    the workflow *looks* configured but behaves differently (e.g. ScheduleNode
+    ``{mode, schedule}`` instead of ``cron`` → silent 5-min fallback;
+    PositionSizingNode ``size_type`` instead of ``method``). (Blocking when
+    enabled.) Structural, not keyword-based: the allowed set is derived from the
+    registry node class, and unknown / community / dynamic types (no resolvable
+    class) are skipped rather than false-flagged.
 
 Design contract
 ---------------
@@ -58,6 +67,7 @@ from programgarden_core import (
     ErrorLocation,
     ErrorSeverity,
     build_error,
+    suggest_close_match,
 )
 
 # ---------------------------------------------------------------------------
@@ -68,12 +78,14 @@ RULE_ORDER_QTY_FROM_AI = "order_qty_from_ai_response"            # R1
 RULE_STRUCTURED_OUTPUT_NO_SCHEMA = "structured_output_missing_schema"  # R2
 RULE_HARDCODED_ORDER_QTY = "hardcoded_order_quantity"            # R3
 RULE_ORDER_IGNORED_FIELD = "order_ignored_field"                # R4
+RULE_UNKNOWN_NODE_FIELD = "unknown_node_field"                  # R5
 
 ALL_RULES: tuple[str, ...] = (
     RULE_ORDER_QTY_FROM_AI,
     RULE_STRUCTURED_OUTPUT_NO_SCHEMA,
     RULE_HARDCODED_ORDER_QTY,
     RULE_ORDER_IGNORED_FIELD,
+    RULE_UNKNOWN_NODE_FIELD,
 )
 
 _RULE_CODE: Dict[str, ErrorCode] = {
@@ -81,18 +93,23 @@ _RULE_CODE: Dict[str, ErrorCode] = {
     RULE_STRUCTURED_OUTPUT_NO_SCHEMA: ErrorCode.SEMANTIC_STRUCTURED_OUTPUT_NO_SCHEMA,
     RULE_HARDCODED_ORDER_QTY: ErrorCode.SEMANTIC_HARDCODED_ORDER_QTY,
     RULE_ORDER_IGNORED_FIELD: ErrorCode.SEMANTIC_ORDER_IGNORED_FIELD,
+    RULE_UNKNOWN_NODE_FIELD: ErrorCode.UNKNOWN_NODE_FIELD,
 }
 
 # Everything off — the default when no config is supplied.
 DEFAULT_SEMANTIC_SEVERITIES: Dict[str, str] = {r: "off" for r in ALL_RULES}
 
-# Chatbot strict preset — reproduces the legacy ``workflow_semantic_lint``
-# behavior exactly (R1/R2 block, R3/R4 advise). Callers opt in with this.
+# Chatbot strict preset — the save-chokepoint anti-pattern gate (R1/R2/R5
+# block, R3/R4 advise). R5 blocks hallucinated / typo'd node config keys
+# (e.g. ScheduleNode {mode,schedule} instead of cron, PositionSizingNode
+# size_type instead of method) that ``extra="allow"`` silently accepts — the
+# workflow looks configured but the extra keys are ignored at runtime.
 STRICT_SEMANTIC_SEVERITIES: Dict[str, str] = {
     RULE_ORDER_QTY_FROM_AI: "error",
     RULE_STRUCTURED_OUTPUT_NO_SCHEMA: "error",
     RULE_HARDCODED_ORDER_QTY: "warning",
     RULE_ORDER_IGNORED_FIELD: "warning",
+    RULE_UNKNOWN_NODE_FIELD: "error",
 }
 
 _SEVERITY_MAP: Dict[str, ErrorSeverity] = {
@@ -171,6 +188,47 @@ def _is_aiagent_node(node_type: Any) -> bool:
         return False
 
 
+# Structural keys present on every node dict but not always declared as a schema
+# / model field. ``config`` / ``description`` are BaseNode fields; ``plugin`` /
+# ``fields`` are the ConditionNode plugin-binding structure carried at node level.
+# ``credential_id`` is the canonical credential-binding key (``nodes[].credential_id``
+# + top-level ``credentials[]``): the executor's universal node-creation layer reads
+# it (``config.get("credential_id")`` → ``_inject_credentials``) for every node type,
+# so no per-node schema declares it — flagging it would block every credential-bound
+# workflow at the strict save gate.
+_RESERVED_NODE_KEYS: frozenset = frozenset(
+    {"id", "type", "category", "position", "config", "description", "plugin",
+     "fields", "credential_id"}
+)
+
+
+def _node_allowed_keys(node_type: Any) -> Optional[frozenset]:
+    """Allowed top-level config keys for a registered node type, or None.
+
+    The allowed set is the union of the node's declared Pydantic model fields,
+    its ``get_field_schema()`` keys (the AI/UI-facing schema), and the reserved
+    structural keys. Returns None when ``node_type`` does not resolve to a
+    registered class (unknown / community / dynamic) — R5 skips those, since
+    their schema is unknown and any key would otherwise be false-flagged.
+    Never raises.
+    """
+    cls = _node_class(node_type)
+    if cls is None:
+        return None
+    allowed = set(_RESERVED_NODE_KEYS)
+    try:
+        allowed |= set(cls.model_fields.keys())
+    except Exception:  # pragma: no cover - defensive
+        pass
+    try:
+        fs = cls.get_field_schema()
+        if isinstance(fs, dict):
+            allowed |= set(fs.keys())
+    except Exception:  # pragma: no cover - defensive
+        pass
+    return frozenset(allowed)
+
+
 # ---------------------------------------------------------------------------
 # Binding helpers
 # ---------------------------------------------------------------------------
@@ -261,6 +319,7 @@ def analyze_workflow_semantics(
     sev_r2 = _enabled(severities, RULE_STRUCTURED_OUTPUT_NO_SCHEMA)
     sev_r3 = _enabled(severities, RULE_HARDCODED_ORDER_QTY)
     sev_r4 = _enabled(severities, RULE_ORDER_IGNORED_FIELD)
+    sev_r5 = _enabled(severities, RULE_UNKNOWN_NODE_FIELD)
 
     # Index node id → node, and whether any PositionSizingNode exists (R3).
     nodes_by_id: Dict[str, Dict[str, Any]] = {}
@@ -282,6 +341,41 @@ def analyze_workflow_semantics(
         node_type = node.get("type")
         node_id = node.get("id") if isinstance(node.get("id"), str) else "?"
 
+        # ── R5: unknown node config key (hallucinated / typo'd field) ──────
+        # Runs for every node. Structural: the allowed set comes from the
+        # registry node class; unknown / dynamic types (allowed is None) are
+        # skipped rather than false-flagged.
+        if sev_r5 is not None:
+            allowed = _node_allowed_keys(node_type)
+            if allowed is not None:
+                for key in node.keys():
+                    if key in allowed:
+                        continue
+                    errors.append(build_error(
+                        ErrorCode.UNKNOWN_NODE_FIELD,
+                        f"Node '{node_id}' ({node_type}) has field '{key}', which is not "
+                        f"in this node's schema. Pydantic accepts it (extra='allow') but "
+                        f"the executor never reads it, so the workflow looks configured "
+                        f"but behaves differently than it appears.",
+                        severity=sev_r5,
+                        location=ErrorLocation(
+                            node_id=node_id,
+                            node_type=node_type if isinstance(node_type, str) else None,
+                            field_path=key if isinstance(key, str) else None,
+                        ),
+                        available_values=(
+                            suggest_close_match(key, sorted(allowed))
+                            if isinstance(key, str) else None
+                        ),
+                        suggestion=(
+                            f"'{key}' 는 {node_type} 노드에 없는 필드예요. 오탈자이거나 "
+                            f"다른 노드의 필드일 수 있습니다. 이 노드의 config_schema 에 "
+                            f"정의된 필드만 사용하세요 (예: ScheduleNode 는 cron, "
+                            f"PositionSizingNode 는 method)."
+                        ),
+                        details={"rule": RULE_UNKNOWN_NODE_FIELD, "field": key},
+                    ))
+
         # ── R2: AIAgent structured output with no schema (and no preset) ──
         if sev_r2 is not None and _is_aiagent_node(node_type):
             if node.get("output_format") == "structured":
@@ -396,6 +490,7 @@ __all__ = [
     "RULE_STRUCTURED_OUTPUT_NO_SCHEMA",
     "RULE_HARDCODED_ORDER_QTY",
     "RULE_ORDER_IGNORED_FIELD",
+    "RULE_UNKNOWN_NODE_FIELD",
     "ALL_RULES",
     "DEFAULT_SEMANTIC_SEVERITIES",
     "STRICT_SEMANTIC_SEVERITIES",

{programgarden-1.29.4 → programgarden-1.30.0}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.29.4"
+version = "1.30.0"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -29,7 +29,7 @@ lxml = "^6.0.2"
 pytickersymbols = {version = ">=1.17.5", python = ">=3.12,<4.0"}
 aiosqlite = "^0.20.0"
 litellm = ">=1.40.0"
-programgarden-core = "^1.21.0"
+programgarden-core = "^1.22.0"
 programgarden-finance = "^1.6.14"
 programgarden-community = "^1.13.11"