agentic-project-kit 1.0.1__py3-none-any.whl

agentic_project_kit/gui_command_projection.py

@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterable, Sequence
+
+from agentic_project_kit.command_manifest import SURFACE_VALUES, load_manifest
+
+GUI_SURFACE_LAYERS: dict[str, str] = {
+    "orchestrator": "primary",
+    "diagnostic": "diagnostics",
+    "primitive": "expert",
+}
+GUI_DIAGNOSTIC_PRIORITY_VALUES = {
+    "not_diagnostic",
+    "common_blocker",
+    "claim_evidence",
+    "specialized_audit",
+    "reference_lookup",
+    "advanced_diagnostic",
+}
+GUI_CLAIM_EVIDENCE_VALUES = {
+    "none",
+    "gate_output_required",
+    "exact_ref_required",
+    "release_evidence_required",
+    "pr_or_remote_evidence_required",
+}
+GUI_SAFETY_REVIEW_VALUES = {
+    "read_only",
+    "dry_run_available",
+    "manual_safety_review",
+    "destructive_gate_required",
+}
+
+COMMON_BLOCKER_DIAGNOSTICS = {
+    "agentic-kit audit-status-current-state",
+    "agentic-kit check-docs",
+    "agentic-kit docs-audit",
+    "agentic-kit doctor",
+    "agentic-kit workflow status",
+    "agentic-kit workflow-guard check",
+}
+
+
+@dataclass(frozen=True)
+class GuiCommandProjectionEntry:
+    qualified_name: str
+    group: str
+    surface: str
+    layer: str
+    safety: str
+    dry_run_available: bool
+    diagnostic_priority: str
+    claim_evidence: str
+    safety_review: str
+    when_to_use: str
+
+    def as_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class GuiCommandBinding:
+    source_id: str
+    wrapper_command: tuple[str, ...]
+    qualified_name: str
+    surface: str
+    layer: str
+    safety: str
+    diagnostic_priority: str
+    claim_evidence: str
+    safety_review: str
+
+    def as_dict(self) -> dict[str, object]:
+        data = asdict(self)
+        data["wrapper_command"] = list(self.wrapper_command)
+        return data
+
+
+@dataclass(frozen=True)
+class GuiCommandProjection:
+    root: str
+    command_count: int
+    entries: tuple[GuiCommandProjectionEntry, ...]
+    findings: tuple[str, ...]
+
+    @property
+    def ok(self) -> bool:
+        return not self.findings
+
+    @property
+    def default_layer(self) -> str:
+        return "primary"
+
+    @property
+    def default_entries(self) -> tuple[GuiCommandProjectionEntry, ...]:
+        return self.entries_for_layer(self.default_layer)
+
+    def entries_for_layer(self, layer: str) -> tuple[GuiCommandProjectionEntry, ...]:
+        return tuple(entry for entry in self.entries if entry.layer == layer)
+
+    def surface_counts(self) -> dict[str, int]:
+        return {
+            surface: len([entry for entry in self.entries if entry.surface == surface])
+            for surface in sorted(GUI_SURFACE_LAYERS)
+        }
+
+    def layer_counts(self) -> dict[str, int]:
+        return {
+            layer: len([entry for entry in self.entries if entry.layer == layer])
+            for layer in ("primary", "diagnostics", "expert")
+        }
+
+    def diagnostic_priority_counts(self) -> dict[str, int]:
+        return {
+            priority: len([entry for entry in self.entries if entry.diagnostic_priority == priority])
+            for priority in sorted(GUI_DIAGNOSTIC_PRIORITY_VALUES)
+        }
+
+    def guided_diagnostic_entries(self) -> tuple[GuiCommandProjectionEntry, ...]:
+        return tuple(
+            entry for entry in self.entries if entry.diagnostic_priority == "common_blocker"
+        )
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "schema_version": 1,
+            "kind": "gui_command_projection",
+            "root": self.root,
+            "status": "PASS" if self.ok else "FAIL",
+            "default_layer": self.default_layer,
+            "command_count": self.command_count,
+            "surface_counts": self.surface_counts(),
+            "layer_counts": self.layer_counts(),
+            "diagnostic_priority_counts": self.diagnostic_priority_counts(),
+            "guided_diagnostic_count": len(self.guided_diagnostic_entries()),
+            "findings": list(self.findings),
+            "entries": [entry.as_dict() for entry in self.entries],
+        }
+
+
+def build_gui_command_projection(
+    root: Path = Path("."),
+    *,
+    manifest: dict[str, Any] | None = None,
+) -> GuiCommandProjection:
+    data = manifest if manifest is not None else load_manifest(root)
+    commands = _manifest_commands(data)
+    entries: list[GuiCommandProjectionEntry] = []
+    findings: list[str] = []
+
+    for command in commands:
+        qualified = str(command.get("qualified_name") or "")
+        surface = str(command.get("surface") or "")
+        if surface not in SURFACE_VALUES:
+            findings.append(f"{qualified or '<unknown>'}: invalid surface {surface!r}")
+            continue
+        layer = GUI_SURFACE_LAYERS[surface]
+        entries.append(
+            GuiCommandProjectionEntry(
+                qualified_name=qualified,
+                group=str(command.get("group") or ""),
+                surface=surface,
+                layer=layer,
+                safety=str(command.get("safety") or ""),
+                dry_run_available=bool(command.get("dry_run_available")),
+                diagnostic_priority=diagnostic_priority_for_command(command),
+                claim_evidence=claim_evidence_for_command(command),
+                safety_review=safety_review_for_command(command),
+                when_to_use=str(command.get("when_to_use") or ""),
+            )
+        )
+
+    if not entries:
+        findings.append("command manifest contains no GUI-projectable commands")
+    for surface, layer in GUI_SURFACE_LAYERS.items():
+        if not any(entry.surface == surface for entry in entries):
+            findings.append(f"command manifest contains no {surface} commands for GUI layer {layer}")
+
+    return GuiCommandProjection(
+        root=root.resolve().as_posix(),
+        command_count=len(commands),
+        entries=tuple(sorted(entries, key=lambda entry: entry.qualified_name)),
+        findings=tuple(findings),
+    )
+
+
+def gui_command_bindings(
+    sources: Iterable[object],
+    root: Path = Path("."),
+    *,
+    manifest: dict[str, Any] | None = None,
+) -> tuple[GuiCommandBinding, ...]:
+    data = manifest if manifest is not None else load_manifest(root)
+    bindings: list[GuiCommandBinding] = []
+    for source in sources:
+        wrapper = _wrapper_command(source)
+        if not _is_agentic_kit_wrapper(wrapper):
+            continue
+        command = resolve_manifest_command(wrapper, data)
+        if command is None:
+            continue
+        surface = str(command.get("surface") or "")
+        if surface not in SURFACE_VALUES:
+            continue
+        bindings.append(
+            GuiCommandBinding(
+                source_id=str(getattr(source, "command_id", getattr(source, "action_id", "<unknown>"))),
+                wrapper_command=wrapper,
+                qualified_name=str(command.get("qualified_name") or ""),
+                surface=surface,
+                layer=GUI_SURFACE_LAYERS[surface],
+                safety=str(command.get("safety") or ""),
+                diagnostic_priority=diagnostic_priority_for_command(command),
+                claim_evidence=claim_evidence_for_command(command),
+                safety_review=safety_review_for_command(command),
+            )
+        )
+    return tuple(bindings)
+
+
+def diagnostic_priority_for_command(command: dict[str, Any]) -> str:
+    qualified = str(command.get("qualified_name") or "")
+    surface = str(command.get("surface") or "")
+    group = str(command.get("group") or "")
+    leaf = qualified.split()[-1] if qualified else ""
+    if surface != "diagnostic":
+        return "not_diagnostic"
+    if qualified in COMMON_BLOCKER_DIAGNOSTICS:
+        return "common_blocker"
+    claim_evidence = claim_evidence_for_command(command)
+    if claim_evidence in {
+        "exact_ref_required",
+        "release_evidence_required",
+        "pr_or_remote_evidence_required",
+    }:
+        return "claim_evidence"
+    if group in {"audit", "dpa"} or leaf.startswith("audit-") or leaf.endswith("-audit"):
+        return "specialized_audit"
+    if group in {"commands", "command", "reference"} or leaf in {"list", "show", "render-md"}:
+        return "reference_lookup"
+    return "advanced_diagnostic"
+
+
+def claim_evidence_for_command(command: dict[str, Any]) -> str:
+    qualified = str(command.get("qualified_name") or "")
+    group = str(command.get("group") or "")
+    words = set(qualified.split())
+    if "dpa" in words and any(
+        marker in qualified
+        for marker in (
+            "adoption-assessment",
+            "closeout",
+            "probe",
+            "readiness",
+            "stable",
+            "strict",
+        )
+    ):
+        return "exact_ref_required"
+    if group == "release" or "release" in words or "post-release" in qualified:
+        return "release_evidence_required"
+    if group == "transfer" and any(
+        marker in qualified
+        for marker in (" pr-", " post-merge", " push-", " publish-", " merge")
+    ):
+        return "pr_or_remote_evidence_required"
+    if qualified in COMMON_BLOCKER_DIAGNOSTICS or qualified.startswith("agentic-kit audit-"):
+        return "gate_output_required"
+    return "none"
+
+
+def safety_review_for_command(command: dict[str, Any]) -> str:
+    safety = str(command.get("safety") or "")
+    dry_run_available = bool(command.get("dry_run_available"))
+    if safety == "READ_ONLY":
+        return "read_only"
+    if safety == "DESTRUCTIVE":
+        return "destructive_gate_required"
+    if dry_run_available:
+        return "dry_run_available"
+    return "manual_safety_review"
+
+
+def validate_gui_command_bindings(
+    sources: Iterable[object],
+    root: Path = Path("."),
+    *,
+    manifest: dict[str, Any] | None = None,
+) -> tuple[str, ...]:
+    data = manifest if manifest is not None else load_manifest(root)
+    findings: list[str] = []
+    for source in sources:
+        source_id = str(getattr(source, "command_id", getattr(source, "action_id", "<unknown>")))
+        wrapper = _wrapper_command(source)
+        if not wrapper:
+            continue
+        if not _is_agentic_kit_wrapper(wrapper):
+            continue
+        command = resolve_manifest_command(wrapper, data)
+        if command is None:
+            findings.append(
+                f"{source_id}: wrapper command is not registered in command manifest: "
+                + " ".join(wrapper)
+            )
+            continue
+        surface = str(command.get("surface") or "")
+        if surface not in SURFACE_VALUES:
+            findings.append(f"{source_id}: wrapper command has invalid surface {surface!r}")
+    return tuple(findings)
+
+
+def resolve_manifest_command(
+    wrapper_command: Sequence[str],
+    manifest: dict[str, Any],
+) -> dict[str, Any] | None:
+    wrapper = tuple(str(part) for part in wrapper_command)
+    if not _is_agentic_kit_wrapper(wrapper):
+        return None
+    commands = _manifest_commands(manifest)
+    candidates: list[tuple[tuple[str, ...], dict[str, Any]]] = []
+    for command in commands:
+        qualified = str(command.get("qualified_name") or "")
+        if not qualified:
+            continue
+        vector = tuple(qualified.split())
+        candidates.append((vector, command))
+    for vector, command in sorted(candidates, key=lambda item: len(item[0]), reverse=True):
+        if tuple(wrapper[: len(vector)]) == vector:
+            return command
+    return None
+
+
+def _manifest_commands(manifest: dict[str, Any]) -> list[dict[str, Any]]:
+    commands = manifest.get("commands") if isinstance(manifest, dict) else None
+    if not isinstance(commands, list):
+        return []
+    return [command for command in commands if isinstance(command, dict)]
+
+
+def _wrapper_command(source: object) -> tuple[str, ...]:
+    if hasattr(source, "wrapper_command"):
+        wrapper = getattr(source, "wrapper_command")
+    elif hasattr(source, "command"):
+        wrapper = getattr(source, "command")
+    else:
+        wrapper = ()
+    if not isinstance(wrapper, tuple):
+        wrapper = tuple(wrapper or ())
+    return tuple(str(part) for part in wrapper)
+
+
+def _is_agentic_kit_wrapper(wrapper: Sequence[str]) -> bool:
+    return bool(wrapper) and str(wrapper[0]) == "agentic-kit"

agentic_project_kit/gui_communication_modes.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CommunicationModeDefinition:
+    mode_id: str
+    label: str
+    role: str
+    is_default: bool
+    safety_note: str
+    explanation: str
+    example: str
+    next_step_hint: str
+    walkthrough_steps: tuple[str, ...]
+    default_expanded_groups: tuple[str, ...]
+
+
+COMMUNICATION_MODE_DEFINITIONS: tuple[CommunicationModeDefinition, ...] = (
+    CommunicationModeDefinition(
+        mode_id="file_transfer",
+        label="File Transfer",
+        role="Standard",
+        is_default=True,
+        safety_note="Normal path: typed transfer files, work orders, reports, evidence, no chat paste required.",
+        explanation=(
+            "Normal mode. Write the task to the repo-backed transfer task, send g/go in chat, "
+            "then read the result. Minimizes copy-and-paste."
+        ),
+        example=(
+            "Example: Send the task, type g/go in the LLM chat, then use Read or "
+            "agentic-kit transfer continue --json for the repo-backed reply."
+        ),
+        next_step_hint="Type your task below, click Send, then write g in chat.",
+        walkthrough_steps=(
+            "Start new work.",
+            "Type your task and Send; it is published to the repo.",
+            "Write g in chat; the assistant reads the task and works.",
+            "Click Check, then Finish & publish.",
+        ),
+        default_expanded_groups=("task_editor",),
+    ),
+    CommunicationModeDefinition(
+        mode_id="remote",
+        label="Remote",
+        role="GitHub/PR/CI",
+        is_default=False,
+        safety_note="Remote work is visible here but mutations remain strictly wrapper- and gatekeeper-guarded.",
+        explanation=(
+            "PR/CI/GitHub focused mode. Use safe read-only checks and bounded wrappers; "
+            "do not bypass governance."
+        ),
+        example=(
+            "Example: Ask the assistant to work through PR/CI, then inspect "
+            "agentic-kit transfer patch-cycle-status --json and evidence links."
+        ),
+        next_step_hint="Open or check the pull request; CI verifies it before merge.",
+        walkthrough_steps=(
+            "Start new work.",
+            "Make your changes.",
+            "Check.",
+            "Finish & publish opens a pull request; CI verifies before merge.",
+        ),
+        default_expanded_groups=(),
+    ),
+    CommunicationModeDefinition(
+        mode_id="copy_paste",
+        label="Copy-and-Paste",
+        role="Recovery/Fallback",
+        is_default=False,
+        safety_note=(
+            "Fallback only for terminal loss, Python startup issues, filesystem errors, "
+            "network trouble before push, broken logs, or hard recovery."
+        ),
+        explanation=(
+            "Recovery fallback only for terminal loss or missing remote access. "
+            "Not the normal operating mode."
+        ),
+        example=(
+            "Example: Open a local terminal and paste exactly one complete recovery block "
+            "from the LLM, then return only LOG/RC or the requested evidence."
+        ),
+        next_step_hint="Run the shown command locally and paste the result back.",
+        walkthrough_steps=(
+            "Start new work.",
+            "Copy the assistant's command.",
+            "Run it locally.",
+            "Paste the result back. Use only when no repo connection works.",
+        ),
+        default_expanded_groups=("copy_paste_tools",),
+    ),
+)
+
+DEFAULT_COMMUNICATION_MODE = "file_transfer"
+
+
+def communication_mode_definitions() -> tuple[CommunicationModeDefinition, ...]:
+    return COMMUNICATION_MODE_DEFINITIONS
+
+
+def communication_mode_ids() -> frozenset[str]:
+    return frozenset(definition.mode_id for definition in COMMUNICATION_MODE_DEFINITIONS)
+
+
+def communication_mode_definition(mode: str) -> CommunicationModeDefinition:
+    normalized = mode if mode in communication_mode_ids() else DEFAULT_COMMUNICATION_MODE
+    return next(
+        definition for definition in COMMUNICATION_MODE_DEFINITIONS if definition.mode_id == normalized
+    )
+
+
+def communication_mode_explanation(mode: str) -> str:
+    return communication_mode_definition(mode).explanation
+
+
+def communication_mode_example(mode: str) -> str:
+    return communication_mode_definition(mode).example
+
+
+def communication_mode_next_step_hint(mode: str) -> str:
+    return communication_mode_definition(mode).next_step_hint
+
+
+def communication_mode_walkthrough_steps(mode: str) -> tuple[str, ...]:
+    return communication_mode_definition(mode).walkthrough_steps
+
+
+def communication_mode_default_expanded_groups(mode: str) -> tuple[str, ...]:
+    return communication_mode_definition(mode).default_expanded_groups

agentic_project_kit/gui_dry_run.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import SimpleNamespace
+import importlib
+from pathlib import Path
+
+from agentic_project_kit.action_registry import list_actions
+from agentic_project_kit.gui_presenter import build_no_window_presenter_result
+from agentic_project_kit.gui_action_execution import run_bounded_read_only_action
+from agentic_project_kit.gui_layout_plan import build_layout_plan, render_layout_plan
+from agentic_project_kit.gui_tkinter_renderer import render_layout_to_tkinter, render_tkinter_result_summary
+from agentic_project_kit.gui_window_guard import check_window_launch_ready, render_window_guard_result
+from agentic_project_kit.gui_output_status_panel import build_output_status_panel, render_output_status_panel
+
+
+@dataclass(frozen=True)
+class GuiDryRunResult:
+    ok: bool
+    tkinter_available: bool
+    action_registry_available: bool
+    action_specs_available: bool
+    presenter_available: bool
+    presenter_action_count: int
+    presenter_preview: str
+    mode_guard_available: bool
+    shell_adapters_absent: bool
+    message: str
+
+    @property
+    def exit_code(self) -> int:
+        return 0 if self.ok else 1
+
+
+class DryRunRoot:
+    def __init__(self) -> None:
+        self.title_value = ""
+        self.geometry_value = ""
+
+    def title(self, value: str) -> None:
+        self.title_value = value
+
+    def geometry(self, value: str) -> None:
+        self.geometry_value = value
+
+
+def _module_available(name: str) -> bool:
+    try:
+        importlib.import_module(name)
+    except Exception:
+        return False
+    return True
+
+
+def _mode_guard_available(project_root: Path) -> bool:
+    ns_path = project_root / "ns"
+    if not ns_path.exists():
+        return False
+    ns_text = ns_path.read_text(encoding="utf-8")
+    return "mode-check" in ns_text and "mode-write" in ns_text
+
+
+def _shell_adapters_absent(project_root: Path) -> bool:
+    return not any((project_root / "tools").glob("ns_*.sh"))
+
+
+def run_gui_dry_run(project_root: Path | None = None) -> GuiDryRunResult:
+    root = Path.cwd() if project_root is None else project_root
+    tkinter_available = _module_available("tkinter")
+    action_registry_available = _module_available("agentic_project_kit.action_registry")
+    action_specs_available = _module_available("agentic_project_kit.action_specs")
+    mode_guard_available = _mode_guard_available(root)
+    shell_adapters_absent = _shell_adapters_absent(root)
+    presenter = build_no_window_presenter_result(list_actions())
+    ok = all((
+        action_registry_available,
+        action_specs_available,
+        mode_guard_available,
+        shell_adapters_absent,
+        presenter.ok,
+    ))
+    message = "GUI dry-run passed without opening a window." if ok else "GUI dry-run failed."
+    return GuiDryRunResult(
+        ok=ok,
+        tkinter_available=tkinter_available,
+        action_registry_available=action_registry_available,
+        action_specs_available=action_specs_available,
+        presenter_available=presenter.ok,
+        presenter_action_count=presenter.action_count,
+        presenter_preview=presenter.rendered,
+        mode_guard_available=mode_guard_available,
+        shell_adapters_absent=shell_adapters_absent,
+        message=message,
+    )
+
+
+def render_result(result: GuiDryRunResult) -> str:
+    lines = [
+        "GUI DRY RUN",
+        "Safety: no window is opened; no files, branches, tags, releases, PRs, or remote state are changed.",
+        f"tkinter_available={str(result.tkinter_available).lower()}",
+        f"window_launch_ready={str(check_window_launch_ready().ok).lower()}",
+        "tkinter_note=nonblocking for --dry-run; required only for real window launch",
+        f"action_registry_available={str(result.action_registry_available).lower()}",
+        f"action_specs_available={str(result.action_specs_available).lower()}",
+        f"presenter_available={str(result.presenter_available).lower()}",
+        f"presenter_action_count={result.presenter_action_count}",
+        "presenter_preview_begin",
+        result.presenter_preview,
+        "presenter_preview_end",
+        f"mode_guard_available={str(result.mode_guard_available).lower()}",
+        f"shell_adapters_absent={str(result.shell_adapters_absent).lower()}",
+        f"message={result.message}",
+    ]
+    plan = build_layout_plan()
+    rendered = render_layout_to_tkinter(DryRunRoot(), plan)
+    lines.extend([
+        "output_status_panel_begin",
+        render_output_status_panel(
+            build_output_status_panel(
+                branch="dry-run",
+                dirty=False,
+                latest_output="GUI dry-run initialized without executing an action.",
+                terminal_log="NONE",
+                terminal_log_remote="NONE",
+                terminal_log_local="NONE",
+                evidence_state="not_required",
+                summary="No command summary exists in dry-run mode.",
+            )
+        ),
+        "output_status_panel_end",
+        "layout_plan_begin",
+        render_layout_plan(plan),
+        "layout_plan_end",
+        "tkinter_render_begin",
+        render_tkinter_result_summary(rendered),
+        "tkinter_render_end",
+        "window_guard_begin",
+        render_window_guard_result(check_window_launch_ready()),
+        "window_guard_end",
+        "real_window_opened=false",
+        "### RESULT: PASS ###" if result.ok else "### RESULT: FAIL ###",
+    ])
+    return "\n".join(lines)
+
+# GUI_EXECUTION_RESULT_WIRING_OVERRIDE_BEGIN
+_run_gui_dry_run_base = run_gui_dry_run
+_render_result_base = render_result
+
+def run_gui_dry_run(project_root: Path | None = None, *, action_name: str | None = None):
+    base_result = _run_gui_dry_run_base(project_root)
+    if not action_name:
+        return base_result
+    execution_result = run_bounded_read_only_action(list_actions(), action_name)
+    return SimpleNamespace(base_result=base_result, execution_result=execution_result)
+
+def render_result(result) -> str:
+    base_result = getattr(result, "base_result", result)
+    output = _render_result_base(base_result)
+    execution = getattr(result, "execution_result", None)
+    if execution is None:
+        return output
+    lines = output.splitlines()
+    safety_class = str(getattr(execution.safety_class, "value", execution.safety_class)).strip().lower().replace("_", "-").rsplit(".", 1)[-1]
+    execution_lines = [
+        "execution_result_begin",
+        "GUI ACTION EXECUTION RESULT",
+        f"action={execution.action_name}",
+        f"safety_class={safety_class}",
+        f"allowed={str(execution.allowed).lower()}",
+        f"executed={str(execution.executed).lower()}",
+        f"returncode={execution.returncode}",
+        f"message={execution.message}",
+        f"output={execution.output}",
+        "execution_result_end",
+    ]
+    if "real_window_opened=false" in lines:
+        index = lines.index("real_window_opened=false")
+        lines[index:index] = execution_lines
+    else:
+        lines.extend(execution_lines)
+    return chr(10).join(lines)
+
+def _render_help() -> str:
+    return chr(10).join([
+        "usage: ./ns gui [--dry-run] [--action ACTION_NAME]",
+        "Safety: help only; no window is opened and no action is executed.",
+        "options:",
+        "  --help, -h              Show this help and exit successfully.",
+        "  --dry-run               Render the no-window GUI dry-run.",
+        "  --action ACTION_NAME    Include a bounded action execution result.",
+        "### RESULT: PASS ###",
+    ])
+
+
+def main(argv: list[str] | None = None) -> int:
+    import sys
+    args = list(sys.argv[1:] if argv is None else argv)
+    action_name = None
+    if args in (["--help"], ["-h"]):
+        print(_render_help())
+        return 0
+    if args == ["--dry-run"]:
+        args = []
+    if args:
+        if len(args) == 2 and args[0] == "--action":
+            action_name = args[1]
+        else:
+            print("usage: ./ns gui [--dry-run] [--action ACTION_NAME]")
+            print("### RESULT: FAIL ###")
+            return 2
+    print(render_result(run_gui_dry_run(action_name=action_name)))
+    return 0
+# GUI_EXECUTION_RESULT_WIRING_OVERRIDE_END
+
+if __name__ == "__main__":
+    import sys
+
+    raise SystemExit(main(sys.argv[1:]))