teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/adapters/inbound/textual_plan_reviewer_helpers.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+import logging
+import re
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_app import ReviewerApp
+    from teddy_executor.core.domain.models.plan import ActionData
+    from teddy_executor.core.domain.models.project_context import ContextItem
+
+logger = logging.getLogger(__name__)
+
+MAX_LABEL_LENGTH = 60
+
+
+def extract_status_emoji(raw_status: str) -> str:
+    """Extracts the status emoji, preferring anchored status lines."""
+    # Priority 1: Anchored status line (matches SessionPruningService logic)
+    anchored_match = re.search(
+        r"^- \*\*Status:\*\*.*([🟢🟡🔴])", raw_status, re.MULTILINE
+    )
+    if anchored_match:
+        return anchored_match.group(1)
+
+    # Priority 2: Fallback to first occurring emoji (resilience for unanchored strings)
+    emojis = re.findall(r"[🟢🟡🔴]", raw_status)
+    return emojis[0] if emojis else ""
+
+
+def populate_context_detail(app: "ReviewerApp", pane: Any, data: Any) -> None:
+    """Extract context-specific detail population logic."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_widgets import DetailItem
+    from teddy_executor.core.domain.models.project_context import ContextItem
+    from teddy_executor.core.utils.markdown import is_session_history_path
+
+    if isinstance(data, ContextItem):
+        pane.append(DetailItem("Path", data.path))
+        pane.append(DetailItem("Tokens", f"{data.token_count / 1000.0:.1f}k"))
+        status_map = {
+            "M": "Modified",
+            "??": "Untracked",
+            "U": "Untracked",
+            "A": "Added",
+            "D": "Deleted",
+        }
+        status_text = status_map.get(data.git_status.strip(), "Unmodified")
+        pane.append(DetailItem("Git Status", status_text))
+        pane.append(DetailItem("Scope", data.scope))
+        if data.auto_prune_reason:
+            pane.append(DetailItem("Auto-Prune", data.auto_prune_reason))
+    elif isinstance(data, dict) and data.get("type") == "SYSTEM_PROMPT":
+        pane.append(DetailItem("Agent", data.get("agent", "Unknown")))
+        pane.append(DetailItem("Tokens", f"{data.get('tokens', 0) / 1000.0:.1f}k"))
+    elif app.project_context:
+        # Context Aggregate View - Only sum SELECTED items
+        selected_items = [i for i in app.project_context.items if i.selected]
+        selected_file_tokens = sum(i.token_count for i in selected_items)
+        system_info_tokens = app.project_context.content_tokens - selected_file_tokens
+        total_tokens = (
+            app.project_context.content_tokens
+            + app.project_context.system_prompt_tokens
+        )
+        window_val = (
+            f"{app.project_context.total_window / 1000.0:.0f}k"
+            if app.project_context.total_window > 0
+            else "???"
+        )
+        pane.append(
+            DetailItem(
+                "Total Context",
+                f"{total_tokens / 1000.0:.1f}k / {window_val} tokens",
+            )
+        )
+        pane.append(
+            DetailItem(
+                "• System",
+                f"{(app.project_context.system_prompt_tokens + system_info_tokens) / 1000.0:.1f}k",
+            )
+        )
+        session_tokens = sum(
+            i.token_count
+            for i in selected_items
+            if i.scope == "Session" and not is_session_history_path(i.path)
+        )
+        turn_tokens = sum(
+            i.token_count
+            for i in selected_items
+            if i.scope == "Turn" and not is_session_history_path(i.path)
+        )
+        history_tokens = sum(
+            i.token_count for i in selected_items if is_session_history_path(i.path)
+        )
+
+        pane.append(DetailItem("• Session", f"{session_tokens / 1000.0:.1f}k"))
+        pane.append(DetailItem("• Turn", f"{turn_tokens / 1000.0:.1f}k"))
+        pane.append(DetailItem("• History", f"{history_tokens / 1000.0:.1f}k"))
+
+
+# Editor helpers moved to textual_plan_reviewer_editor.py
+
+
+def format_context_item_label(item: "ContextItem") -> str:
+    """Format a context item label according to UI standards."""
+    status_colors = {
+        "M": "yellow",
+        "??": "green",
+        "A": "green",
+        "D": "red",
+        "U": "green",
+    }
+    clean_status = item.git_status.strip()
+    display_status = "U" if clean_status == "??" else clean_status
+    status_part = (
+        f" [[{status_colors.get(clean_status, 'white')}]{display_status}[/]]"
+        if clean_status
+        else ""
+    )
+    token_str = f"{item.token_count / 1000.0:.1f}k"
+
+    from teddy_executor.core.utils.markdown import get_session_history_display_name
+
+    disp_name = get_session_history_display_name(item.path)
+    display_path = disp_name if disp_name else item.path
+
+    if not item.selected:
+        return f"  [s dim]{display_path}{status_part} {token_str}[/]"
+    return f"  [bold]{display_path}[/]{status_part} [#888888]{token_str}[/]"
+
+
+def build_context_section(app: "ReviewerApp", tree: Any) -> Any:
+    """Build the 'Context' tree section."""
+    if not app.project_context:
+        return None
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_logic import (
+        CONTEXT_ROOT,
+        SYSTEM_LABEL,
+        SESSION_LABEL,
+        TURN_LABEL,
+        HISTORY_LABEL,
+    )
+    from teddy_executor.core.utils.markdown import (
+        is_session_file_path,
+        is_session_history_path,
+        get_session_history_sort_key,
+    )
+
+    con_root = tree.root.add("[bold]Context[/]", data=CONTEXT_ROOT, expand=False)
+    con_root.add_leaf("[#888888 italic]System:[/]", data=SYSTEM_LABEL)
+    token_str = f" [#888888]{app.project_context.system_prompt_tokens / 1000.0:.1f}k[/]"
+    con_root.add_leaf(
+        f"  [bold]{app.project_context.agent_name}[/]{token_str}",
+        data={
+            "type": "SYSTEM_PROMPT",
+            "agent": app.project_context.agent_name,
+            "tokens": app.project_context.system_prompt_tokens,
+        },
+    )
+
+    # Standard context items grouped by scope
+    for scope, label in [("Session", SESSION_LABEL), ("Turn", TURN_LABEL)]:
+        con_root.add_leaf(f"[#888888 italic]{scope}:[/]", data=label)
+        count = 0
+        for item in app.project_context.items:
+            if item.scope == scope and not is_session_file_path(item.path):
+                con_root.add_leaf(format_context_item_label(item), data=item)
+                count += 1
+        if count == 0:
+            con_root.add_leaf("  [#888888](None)[/]", data=label)
+
+    # Chronological history turns
+    history_items = [
+        item for item in app.project_context.items if is_session_history_path(item.path)
+    ]
+    if history_items:
+        con_root.add_leaf("[#888888 italic]History:[/]", data=HISTORY_LABEL)
+        history_items.sort(key=lambda x: get_session_history_sort_key(x.path))
+        for item in history_items:
+            con_root.add_leaf(format_context_item_label(item), data=item)
+
+    return con_root
+
+
+def handle_mount_logic(app: Any, update_detail_fn: Any) -> None:
+    """Populate the action tree and set title when the app is mounted."""
+    if getattr(app, "_tree_built", False) is True:
+        return
+
+    status_raw = (
+        app.plan.metadata.get("Status") or app.plan.metadata.get("status") or ""
+    )
+    status_emoji = extract_status_emoji(status_raw)
+    title_parts = [part for part in [status_emoji, app.plan.title] if part]
+    app.title = " ".join(title_parts)
+
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_widgets import ActionTree
+
+    tree = app.query_one(ActionTree)
+    tree.show_root = False
+    tree.root.expand()
+
+    # 1. Context Section
+    con_root = build_context_section(app, tree)
+
+    # 2. Rationale Section
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_logic import (
+        RATIONALE_ROOT,
+        ACTION_PLAN_ROOT,
+        ALLOWED_RATIONALE_SECTIONS,
+    )
+
+    rat_root = tree.root.add("[bold]Rationale[/]", data=RATIONALE_ROOT, expand=True)
+
+    # Split on '### ' OR '1. ' (numeric lists at start of line)
+    sections = re.split(r"\n(?=### |\d+\.\s+)", "\n" + app.plan.rationale)
+    current_node = None
+    for section in sections:
+        section = section.strip()
+        if not section:
+            continue
+        lines = section.split("\n")
+        title = re.sub(r"^(?:###\s*|\d+\.\s*)+", "", lines[0]).strip()
+        if title in ALLOWED_RATIONALE_SECTIONS:
+            content = "\n".join(lines[1:]).strip()
+            current_node = rat_root.add_leaf(
+                title,
+                data={"type": "RATIONALE_SECTION", "title": title, "content": content},
+            )
+        elif current_node:
+            current_node.data["content"] += "\n\n" + section
+
+    # 3. Action Plan Section
+    act_root = tree.root.add("[bold]Action Plan[/]", data=ACTION_PLAN_ROOT, expand=True)
+    for action in app.plan.actions:
+        if not hasattr(action, "_original_params"):
+            action._original_params = action.params.copy()
+        act_root.add_leaf(format_node_label(action), data=action)
+
+    # Initialize cursor: Context root if available, else Rationale root
+    initial_node = con_root if con_root else rat_root
+
+    tree.move_cursor(initial_node)
+    tree.focus()
+    app._tree_built = True
+    app.call_after_refresh(update_detail_fn, app, initial_node.data)
+
+
+def format_node_label(action: "ActionData") -> str:
+    """Format the label for a tree node based on action state."""
+    from teddy_executor.core.domain.models.plan import ExecutionStatus
+
+    summary = get_action_summary(action)
+    # Ensure Enum types are stringified (e.g. ActionType.CREATE -> "CREATE")
+    type_str = action.type.value if hasattr(action.type, "value") else str(action.type)
+
+    if action.state == ExecutionStatus.RUNNING:
+        return f"[blue][RUNNING] {type_str}: {summary}[/]"
+
+    if action.executed:
+        color = "green" if action.state.value == "SUCCESS" else "red"
+        return f"[{color}][{action.state.value}] {type_str}: {summary}[/]"
+
+    prefix = "[✓]" if action.selected else "[ ]"
+    label = f"{prefix} {type_str}: {summary}"
+    if action.modified:
+        label += " *modified"
+    return label
+
+
+def get_action_summary(action: "ActionData") -> str:
+    """Extract a concise summary for the action."""
+    summary = action.description or ""
+    if not summary:
+        params = action.params
+        summary = str(
+            params.get("path") or params.get("resource") or params.get("command", "")
+        )
+
+    if len(summary) > MAX_LABEL_LENGTH:
+        summary = summary[: MAX_LABEL_LENGTH - 3] + "..."
+    return summary
+
+
+def _apply_param_edit(action: Any, key: str, new_val: str) -> None:
+    """Helper to apply parameter edits back to the action."""
+    list_keys = {"queries", "reference_files"}
+    if key in list_keys:
+        action.params[key] = [v.strip() for v in str(new_val).split(",") if v.strip()]
+    else:
+        action.params[key] = str(new_val)
+
+
+def handle_revert(app: ReviewerApp, node: Any, update_fn: Any) -> None:
+    """Revert manual modifications for the currently highlighted action."""
+    action: Optional[ActionData] = node.data
+    if action and action.modified:
+        action.modified = False
+        action.modified_fields.clear()
+        if hasattr(action, "_original_params"):
+            action.params = action._original_params.copy()
+
+        ptf = getattr(action, "pending_temp_file", None)
+        if isinstance(ptf, str):
+            app._system_env.delete_file(ptf)
+        action.pending_temp_file = None
+
+        app._refresh_node(node)
+        update_fn(app, action)
+        app.refresh_bindings()

teddy_executor/adapters/inbound/textual_plan_reviewer_logic.py

@@ -0,0 +1,345 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, cast
+
+from teddy_executor.adapters.inbound.textual_plan_reviewer_execution import (
+    resolve_action_parameters,
+)
+from teddy_executor.adapters.inbound.textual_plan_reviewer_helpers import (
+    format_node_label,
+)
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_app import ReviewerApp
+    from teddy_executor.core.domain.models.plan import ActionData
+
+
+ALLOWED_RATIONALE_SECTIONS = [
+    "Synthesis",
+    "Justification",
+    "Expectation",
+    "State Dashboard",
+]
+
+# Tree Node Identifiers
+CONTEXT_ROOT = "CONTEXT_ROOT"
+SYSTEM_LABEL = "SYSTEM_LABEL"
+SESSION_LABEL = "SESSION_LABEL"
+TURN_LABEL = "TURN_LABEL"
+HISTORY_LABEL = "HISTORY_LABEL"
+RATIONALE_ROOT = "RATIONALE_ROOT"
+ACTION_PLAN_ROOT = "ACTION_PLAN_ROOT"
+
+
+# Summary logic moved to textual_plan_reviewer_helpers.py
+
+
+def on_tree_node_highlighted(app: "ReviewerApp", event: Any) -> None:
+    """Handle node highlighting to update the detail view."""
+    # event is Tree.NodeHighlighted
+    if event.node and getattr(event.node.tree, "id", None) == "left-pane":
+        # Root node has no data usually, but our virtual roots do
+        _update_detail_view(app, event.node.data)
+    app.refresh_bindings()
+
+
+def _update_detail_view(app: ReviewerApp, data: Any):
+    """Populate the ParameterDetail view or Rationale view."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_widgets import (
+        ParameterDetail,
+    )
+    from textual.widgets import ContentSwitcher
+
+    try:
+        switcher = app.query_one(ContentSwitcher)
+        pane = app.query_one(ParameterDetail)
+    except Exception:
+        return
+
+    if not pane.is_attached:
+        return
+
+    if _is_context_data(data):
+        _update_context_detail(app, switcher, pane, data)
+    elif _is_rationale_section(data):
+        _update_rationale_detail(app, switcher, data)
+    else:
+        _update_action_detail(app, switcher, pane, data)
+
+
+def _is_context_data(data: Any) -> bool:
+    """Check if data belongs to the context section."""
+    from teddy_executor.core.domain.models.project_context import ContextItem
+
+    return (
+        data in (CONTEXT_ROOT, SYSTEM_LABEL, SESSION_LABEL, TURN_LABEL, HISTORY_LABEL)
+        or isinstance(data, ContextItem)
+        or (isinstance(data, dict) and data.get("type") == "SYSTEM_PROMPT")
+    )
+
+
+def _is_rationale_section(data: Any) -> bool:
+    """Check if data is a rationale section dict."""
+    return isinstance(data, dict) and data.get("type") == "RATIONALE_SECTION"
+
+
+def _update_context_detail(app: ReviewerApp, switcher: Any, pane: Any, data: Any):
+    """Render details for context items or aggregates."""
+    switcher.current = "params-view"
+    pane.clear()
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_helpers import (
+        populate_context_detail,
+    )
+
+    populate_context_detail(app, pane, data)
+
+
+def _update_rationale_detail(app: ReviewerApp, switcher: Any, data: dict[str, Any]):
+    """Render details for a rationale section."""
+    from textual.widgets import Markdown
+
+    switcher.current = "rationale-view"
+    app.query_one("#rationale-content", Markdown).update(data["content"])
+
+
+def _update_action_detail(app: ReviewerApp, switcher: Any, pane: Any, data: Any):
+    """Render details for action plan roots or individual actions."""
+    from textual.widgets import Label, ListItem
+
+    switcher.current = "params-view"
+    pane.clear()
+
+    if not data:
+        pane.mount(ListItem(Label("Select an item to view details")))
+        return
+
+    if data == RATIONALE_ROOT:
+        _render_rationale_root_detail(app, pane)
+    elif data == ACTION_PLAN_ROOT:
+        pane.mount(ListItem(Label("Select an action below to view details")))
+    else:
+        _render_action_data_detail(pane, data)
+
+
+def _render_rationale_root_detail(app: ReviewerApp, pane: Any):
+    """Render metadata for the Rationale root node."""
+    from textual.widgets import Tree
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_widgets import DetailItem
+
+    tree = app.query_one(Tree)
+    if tree.cursor_node and tree.cursor_node.data != RATIONALE_ROOT:
+        return
+
+    # Fallback to project_context for agent identity
+    agent = (
+        app.plan.metadata.get("Agent")
+        or app.plan.metadata.get("agent")
+        or (app.project_context.agent_name if app.project_context else "Unknown")
+    )
+    plan_type = (
+        app.plan.metadata.get("Plan Type")
+        or app.plan.metadata.get("plan_type")
+        or "Development"
+    )
+    status = app.plan.metadata.get("Status") or app.plan.metadata.get("status") or "N/A"
+    pane.append(DetailItem("Agent", agent))
+    pane.append(DetailItem("Plan Type", plan_type))
+    pane.append(DetailItem("Status", status))
+
+
+def _render_action_data_detail(pane: Any, data: Any):
+    """Render parameters for an ActionData object."""
+    from teddy_executor.core.domain.models.plan import ActionData
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_widgets import DetailItem
+    from textual.widgets import Label, ListItem
+
+    if isinstance(data, ActionData):
+        for key, val in resolve_action_parameters(data).items():
+            val_str = val.value if hasattr(val, "value") else str(val)
+            pane.append(DetailItem(key, val_str))
+    else:
+        pane.mount(ListItem(Label("Select an item to view details")))
+
+
+async def edit_action_logic(app: ReviewerApp, node: Any, action: ActionData) -> None:
+    """Handles the (e)dit key logic by branching to modals or external editor."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_editor import (
+        handle_edit_action,
+    )
+
+    await handle_edit_action(app, node, action, _update_detail_view)
+
+
+def refresh_node_logic(app: ReviewerApp, node: Any) -> None:
+    """Refresh the label and state of a single tree node."""
+    from teddy_executor.core.domain.models.plan import ActionData
+    from teddy_executor.core.domain.models.project_context import ContextItem
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_helpers import (
+        format_context_item_label,
+    )
+
+    if isinstance(node.data, ActionData):
+        node.label = format_node_label(node.data)
+    elif isinstance(node.data, ContextItem):
+        node.label = format_context_item_label(node.data)
+
+
+def on_mount_logic(app: Any) -> None:
+    """Delegate tree population and title setting."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_helpers import (
+        handle_mount_logic,
+    )
+
+    handle_mount_logic(app, _update_detail_view)
+
+
+def check_action_logic(app: ReviewerApp, action_name: str) -> bool:
+    """Gate for enabling/disabling bindings based on state."""
+    from textual.widgets import Tree
+    from teddy_executor.core.domain.models.plan import ActionData
+
+    tree = app.query_one(Tree)
+    node = tree.cursor_node
+
+    # Navigation and universal actions are always allowed
+    if action_name in (
+        "focus_right",
+        "focus_left",
+        "focus_next",
+        "focus_prev",
+        "jump_next",
+        "jump_prev",
+        "cancel",
+        "submit",
+        "view_plan",
+        "add_message",
+        "toggle_all",
+    ):
+        return True
+
+    from teddy_executor.core.domain.models.project_context import ContextItem
+
+    if not node:
+        return False
+
+    if isinstance(node.data, ContextItem):
+        # Context items only support toggling (space) and universal navigation
+        return action_name in (
+            "toggle_selection",
+            "focus_right",
+            "focus_left",
+            "jump_next",
+            "jump_prev",
+            "cancel",
+        )
+
+    if not isinstance(node.data, ActionData):
+        return False
+
+    data = cast(ActionData, node.data)
+
+    data = cast(ActionData, node.data)
+    results = {
+        "execute_step": not data.executed,
+        "edit_details": not data.executed,
+        "view_details": bool(data.executed),
+        "revert": bool(data.modified) and not data.executed,
+    }
+    return results.get(action_name, True)
+
+
+def toggle_selection_logic(app: ReviewerApp, node: Any) -> None:
+    """Toggle action selection when a node is selected."""
+    from teddy_executor.core.domain.models.plan import ActionData
+    from teddy_executor.core.domain.models.project_context import ContextItem
+
+    data: Any = node.data
+    if isinstance(data, ActionData) and not data.executed:
+        data.selected = not data.selected
+        app._refresh_node(node)
+    elif isinstance(data, ContextItem):
+        data.selected = not data.selected
+        app._refresh_node(node)
+        # Always refresh detail view based on CURRENT highlighting
+        # This ensures totals update if the root is selected but a child is toggled
+        from textual.widgets import Tree
+
+        tree = app.query_one(Tree)
+        if tree.cursor_node:
+            _update_detail_view(app, tree.cursor_node.data)
+
+
+async def on_list_view_selected_logic(app: ReviewerApp, item: Any) -> None:
+    """Handle parameter editing when a DetailItem is selected in the right pane."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_editor import (
+        handle_list_view_selected,
+    )
+
+    await handle_list_view_selected(app, item, _update_detail_view)
+
+
+def revert_logic(app: ReviewerApp, node: Any) -> None:
+    """Revert manual modifications for the currently highlighted action."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_helpers import (
+        handle_revert,
+    )
+
+    handle_revert(app, node, _update_detail_view)
+
+
+async def execute_step_logic(app: ReviewerApp, node: Any) -> None:
+    """Executes the action with real-time state transitions and feedback."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_execution import (
+        execute_step_logic as exec_logic,
+    )
+
+    await exec_logic(app, node, _update_detail_view)
+
+
+async def view_details_logic(app: "ReviewerApp") -> None:
+    """View full execution logs for the currently highlighted action."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_previews import (
+        view_details_handler,
+    )
+
+    await view_details_handler(app)
+
+
+async def view_plan_logic(app: "ReviewerApp") -> None:
+    """Open the full plan.md in an external editor."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_previews import (
+        view_plan_handler,
+    )
+
+    await view_plan_handler(app)
+
+
+async def add_message_logic(app: "ReviewerApp") -> None:
+    """Open the external editor to add/edit the user instruction message."""
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_previews import (
+        add_message_handler,
+    )
+
+    await add_message_handler(app)
+
+
+def toggle_all_logic(app: "ReviewerApp", plan: Any) -> None:
+    """Toggle selection for all actions."""
+    new_state = any(not action.selected for action in plan.actions)
+    for action in plan.actions:
+        action.selected = new_state
+
+    from textual.widgets import Tree
+
+    tree = app.query_one(Tree)
+
+    # Recursively refresh all nodes that contain ActionData
+    def refresh_recursive(node: Any):
+        app._refresh_node(node)
+        for child in node.children:
+            refresh_recursive(child)
+
+    refresh_recursive(tree.root)