github--spec-kit
wehub-resource-sync
91 行
2.7 KiB
Python
91 行
2.7 KiB
Python
"""Runtime helpers for integration commands."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Callable
|
|
from typing import Any
|
|
|
|
from .integration_state import integration_setting, integration_settings
|
|
|
|
|
|
ParseOptions = Callable[[Any, str], dict[str, Any] | None]
|
|
|
|
|
|
def resolve_integration_options(
|
|
integration: Any,
|
|
state: dict[str, Any],
|
|
key: str,
|
|
raw_options: str | None,
|
|
*,
|
|
parse_options: ParseOptions,
|
|
) -> tuple[str | None, dict[str, Any] | None]:
|
|
"""Resolve raw and parsed options for an integration operation."""
|
|
if raw_options is not None:
|
|
return raw_options, parse_options(integration, raw_options)
|
|
|
|
setting = integration_setting(state, key)
|
|
stored_raw = setting.get("raw_options")
|
|
if not isinstance(stored_raw, str):
|
|
stored_raw = None
|
|
|
|
stored_parsed = setting.get("parsed_options")
|
|
if isinstance(stored_parsed, dict):
|
|
return stored_raw, stored_parsed or None
|
|
|
|
if stored_raw:
|
|
return stored_raw, parse_options(integration, stored_raw)
|
|
|
|
return None, None
|
|
|
|
|
|
def with_integration_setting(
|
|
state: dict[str, Any],
|
|
key: str,
|
|
integration: Any,
|
|
*,
|
|
script_type: str | None = None,
|
|
raw_options: str | None = None,
|
|
parsed_options: dict[str, Any] | None = None,
|
|
) -> dict[str, dict[str, Any]]:
|
|
"""Return integration settings with *key* updated."""
|
|
settings = integration_settings(state)
|
|
current = dict(settings.get(key, {}))
|
|
|
|
if script_type:
|
|
current["script"] = script_type
|
|
if raw_options is not None:
|
|
current["raw_options"] = raw_options
|
|
elif "raw_options" in current and not current.get("raw_options"):
|
|
current.pop("raw_options", None)
|
|
|
|
if parsed_options is not None:
|
|
current["parsed_options"] = parsed_options
|
|
elif raw_options is not None:
|
|
current.pop("parsed_options", None)
|
|
|
|
current["invoke_separator"] = integration.effective_invoke_separator(parsed_options)
|
|
settings[key] = current
|
|
return settings
|
|
|
|
|
|
def invoke_separator_for_integration(
|
|
integration: Any,
|
|
state: dict[str, Any],
|
|
key: str,
|
|
parsed_options: dict[str, Any] | None = None,
|
|
) -> str:
|
|
"""Resolve the invocation separator for stored/default integration state."""
|
|
if parsed_options is not None:
|
|
return integration.effective_invoke_separator(parsed_options)
|
|
|
|
setting = integration_setting(state, key)
|
|
stored_separator = setting.get("invoke_separator")
|
|
if isinstance(stored_separator, str) and stored_separator:
|
|
return stored_separator
|
|
|
|
stored_parsed = setting.get("parsed_options")
|
|
if isinstance(stored_parsed, dict):
|
|
return integration.effective_invoke_separator(stored_parsed)
|
|
|
|
return integration.effective_invoke_separator(None)
|