feat(ui): simplify live output and snapshot format

Author: KKamJi98

CHANGELOG.md

@@ -110,6 +110,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Remove the kubectl command footer from Live views and markdown snapshots to reduce on-screen clutter.
 - Bump Kubernetes client to v34.1.0 and refresh supporting dependencies (requests 2.32.5, rich 14.1.0, PyYAML 6.0.3).
 - Raise the minimum supported Python version to 3.9 and align lint/type-check targets.
 

README.md

@@ -12,18 +12,19 @@ Kubernetes 클러스터에서 이벤트, Pod, Node 상태 등을 빠르게 확
 
 1. **Event Monitoring**
    - 2초 간격으로 `kubectl get events`를 재실행해 최신 이벤트를 확인
-   - 실제로 실행된 `kubectl` 명령을 화면 하단에 함께 표기
+   - 실행 명령은 내부적으로 추적하며 UI에는 이벤트 데이터만 표시
 
 2. **Container Monitoring (재시작된 컨테이너 및 로그)**
    - 최근에 재시작된 컨테이너를 시간 기준으로 정렬하여 확인하고, 특정 컨테이너의 이전 로그(-p 옵션)를 확인
 
 3. **Pod Monitoring**
    - 생성된 순서, Running이 아닌 Pod, 전체/정상/비정상 Pod 개수를 조회
    - CPU/Memory 사용량 기준 상위 Pod를 실시간으로 확인하며 NodeGroup 필터링 가능
+   - Ready 지표는 `[ready/total]` 형태로 고정돼 스프레드시트에서 날짜로 변환되지 않음
 
 4. **Node Monitoring**
    - 생성된 순서(노드 정보), Unhealthy Node, CPU/Memory 사용량이 높은 노드를 확인
-   - 모든 뷰에서 NodeGroup(라벨 기반) 필터링을 지원하고, 실행된 `kubectl` 명령을 하단에 노출
+   - 모든 뷰에서 NodeGroup(라벨 기반) 필터링을 지원하고, UI는 노드 지표만 출력
 
 ## Requirements
 
@@ -146,15 +147,25 @@ Kubernetes Monitoring Tool
 #### 스냅샷 저장 (코드블록 + CSV)
 
 - Live 화면에서 `s`, `:s`, `save`, `:save`, `:export` 중 하나를 입력하고 Enter를 누르면 현재 프레임을 코드블록 형태로 `/var/tmp/kmp/YYYY-MM-DD-HH-MM-SS.md` 경로에 저장하고, 동일한 이름의 `.csv` 파일을 동시에 생성합니다.
-- `.md` 파일에는 화면의 표가 가독성 높은 텍스트 코드블록으로 기록되고, 실행 명령이 함께 포함됩니다.
+- `.md` 파일에는 화면의 표를 그대로 옮긴 텍스트 코드블록이 저장되며, 상태 메시지는 이탤릭 한 줄로 시작합니다.
+- 예시:
+
+  ```
+  *:white_check_mark: Event Monitoring*
+
+  Namespace  LastSeen             Type    Reason  Object                              Message
+  ---------  -------------------  ------  ------  ----------------------------------  ---------------
+  default    2025-10-13 14:33:58  Normal  Valid   ClusterSecretStore/parameter-store  store validated
+  ```
+- `.md` 파일에는 실행 명령이 포함되지 않으며, UI에서도 명령은 노출하지 않습니다.
 - `.csv` 파일은 동일한 데이터 집합을 구조화해 제공하며, 별도의 CSV 저장 명령(`csv`, `:csv`)도 동일 포맷으로 동작합니다.
 - 저장이 완료되면 CLI 하단에 두 파일 경로가 표시됩니다. `/var/tmp/kmp`에 쓰기 권한이 없으면 저장이 실패하며, 오류 메시지를 통해 원인을 안내합니다.
 - Live 모드 상단 `command input` 패널에서 `:` 프롬프트에 따라 입력 중인 문자열을 실시간으로 확인할 수 있어, `:save` 등 명령이 제대로 입력됐는지 즉시 파악할 수 있습니다.
 
 ### 1. Event Monitoring
 
 - 전체 이벤트 혹은 `type!=Normal` 이벤트를 2초 간격으로 재조회하여 최신 상태를 확인
-- tail -n [사용자 지정] 개수만큼 표시하며, 실행된 `kubectl get events ...` 명령을 화면 하단에서 확인 가능
+- tail -n [사용자 지정] 개수만큼 표시하며, 이벤트 본문만 갱신
 
 ### 2. Container Monitoring (재시작된 컨테이너 및 로그)
 
@@ -164,12 +175,12 @@ Kubernetes Monitoring Tool
 ### 3. Pod Monitoring (생성된 순서)
 
 - `kubectl get po ... --sort-by=.metadata.creationTimestamp` 명령을 2초 간격으로 실행하여 최신 생성 순서를 확인
-- tail -n [사용자 지정] 개수만큼 표시하며, 화면 하단에서 실행 명령을 확인 가능
+- Ready 컬럼은 `[ready/total]` 형태로 노출되어 스프레드시트 자동 변환을 방지
 
 ### 4. Pod Monitoring (Running이 아닌 Pod 확인)
 
 - `kubectl get pods ... | grep -ivE ' Running'` 명령을 2초 간격으로 실행해 Running이 아닌 Pod만 필터링
-- Pod IP 및 Node Name 표시 옵션 제공, 실행 명령은 항상 화면 하단에 노출
+- Pod IP 및 Node Name 표시 옵션 제공, Ready 컬럼은 `[ready/total]` 형태로 제공
 
 ### 5. Pod Monitoring (전체/정상/비정상 Pod 개수)
 
@@ -179,22 +190,22 @@ Kubernetes Monitoring Tool
 ### 6. Pod Monitoring (CPU/Memory 사용량 높은 순 정렬)
 
 - `kubectl top pod` 결과를 2초마다 조회하고 CPU/Memory 기준으로 정렬하여 상위 N개 Pod를 표시
-- NodeGroup 라벨 기반 필터링을 지원하며, 실제 실행된 명령을 화면 하단에서 확인 가능
+- NodeGroup 라벨 기반 필터링을 지원하며, Ready 컬럼은 `[ready/total]` 형태로 출력
 
 ### 7. Node Monitoring (생성된 순서)
 
 - 노드 생성 시간(`.metadata.creationTimestamp`) 기준으로 정렬된 목록을 2초마다 재조회
-- Zone(`topology.ebs.csi.aws.com/zone`)와 NodeGroup(`NODE_GROUP_LABEL`)을 함께 출력하며, 실행 명령을 하단에 표기
+- Zone(`topology.ebs.csi.aws.com/zone`)와 NodeGroup(`NODE_GROUP_LABEL`)을 함께 출력
 
 ### 8. Node Monitoring (Unhealthy Node 확인)
 
 - `kubectl get nodes ... | grep -ivE ' Ready '` 명령을 2초마다 실행하여 Ready가 아닌 노드만 필터링
-- NodeGroup 필터링을 지원하고, 실행 명령을 하단에서 제공
+- NodeGroup 필터링을 지원하며, 건강 상태와 라벨 정보를 함께 제공
 
 ### 9. Node Monitoring (CPU/Memory 사용량 높은 순 정렬)
 
 - `kubectl top node` 결과를 2초마다 조회해 CPU 혹은 메모리 기준으로 정렬, 상위 N개 노드를 표시
-- NodeGroup 라벨 기반 필터링을 지원하며, 실행된 명령을 항상 하단에서 확인 가능 (`-l node.kubernetes.io/app=<값>`)
+- NodeGroup 라벨 기반 필터링을 지원하며, 리소스 사용량 지표만 출력
 
 ## Development
 

kubernetes_monitoring.py

@@ -317,9 +317,6 @@ def _format_plain_snapshot(payload: SnapshotPayload) -> str:
     else:
         lines.extend(["```", "No data available.", "```"])
 
-    if payload.command:
-        lines.append("*Command*")
-        lines.extend(["```", payload.command.strip(), "```"])
     return "\n".join(lines)
 
 
@@ -330,7 +327,10 @@ def _format_table_snapshot(
     command: str,
     status: str = "info",
 ) -> str:
-    """테이블 데이터를 현재 화면과 유사한 텍스트 코드블록으로 변환."""
+    """테이블 데이터를 현재 화면과 유사한 텍스트 코드블록으로 변환.
+
+    `command` 인자는 호환성을 위해 유지하며 렌더링에는 사용하지 않는다.
+    """
     sanitized_headers = [str(header).strip() for header in headers]
     column_count = len(sanitized_headers)
 
@@ -378,25 +378,13 @@ def _format_row(cells: Sequence[str]) -> str:
 
     icon = _status_icon(status)
     title_text = title.strip() or "Snapshot"
-    title_line = f"{icon} {title_text}" if icon else title_text
-    status_text = status.strip().upper() or "INFO"
+    if icon:
+        title_line = f"*{icon} {title_text}*"
+    else:
+        title_line = f"*{title_text}*"
 
-    command_lines = [
-        line.rstrip() for line in command.strip().splitlines() if line.strip()
-    ]
-    if not command_lines:
-        command_lines = ["(no command)"]
-
-    snapshot_lines: List[str] = [
-        title_line,
-        f"Status: {status_text}",
-        "",
-        *table_lines,
-        "",
-        "Command:",
-        *(f"$ {line}" for line in command_lines),
-    ]
-    return "\n".join(["```text", *snapshot_lines, "```"])
+    snapshot_lines: List[str] = [title_line, "", "```", *table_lines, "```"]
+    return "\n".join(snapshot_lines)
 
 
 def _generate_snapshot_timestamp() -> str:
@@ -709,9 +697,7 @@ def update(
             body_renderable = _merge_renderables(renderable.body_renderables)
             command_descriptor = renderable.command
             input_renderable = renderable.input_panel
-            footer_renderable = renderable.footer_panel or _command_panel(
-                command_descriptor
-            )
+            footer_renderable = renderable.footer_panel
 
         changed = self._sync_input_panel(current_input_state, input_renderable)
 
@@ -823,16 +809,6 @@ def _run_shell_command(command: str) -> Tuple[str, Optional[str]]:
     return completed.stdout, None
 
 
-def _command_panel(command: str) -> Panel:
-    """공통적으로 사용하는 kubectl 명령 패널 생성."""
-    command_display = command.strip() or "(no command)"
-    return Panel(
-        Text(f"$ {command_display}", style="bold cyan"),
-        title="kubectl command",
-        border_style="cyan",
-    )
-
-
 def _merge_renderables(renderables: Sequence[RenderableType]) -> RenderableType:
     """렌더러 목록을 단일 RenderableType으로 축약."""
     if not renderables:
@@ -871,7 +847,8 @@ def __rich_console__(self, console: Console, options):  # type: ignore[override]
         yield self._input_panel
         for item in self.body_renderables:
             yield item
-        yield self._footer_panel
+        if self._footer_panel is not None:
+            yield self._footer_panel
 
     @property
     def input_panel(self) -> RenderableType:
@@ -883,7 +860,7 @@ def footer_panel(self) -> Optional[RenderableType]:
 
 
 def _compose_group(command: str, *renderables: RenderableType) -> _FrameRenderable:
-    """메인 콘텐츠와 kubectl 명령을 묶어 FrameRenderable 생성."""
+    """메인 콘텐츠와 메타데이터(command)를 함께 추적할 렌더러 생성."""
     return _FrameRenderable(command, *renderables)
 
 

tests/test_kubernetes_monitoring.py

@@ -1,7 +1,7 @@
 import os
 import sys
 from pathlib import Path
-from typing import Dict, Optional, Sequence
+from typing import Dict, Optional, Sequence, cast
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -144,15 +144,19 @@ def test_choose_namespace_failure(mock_client):
     kubernetes_monitoring.choose_namespace()
 
 
-def test_save_markdown_snapshot_success(tmp_path, monkeypatch):
+def test_save_markdown_snapshot_success(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
     """코드블록 스냅샷 저장 성공 시 tmp 경로에 파일 생성."""
     monkeypatch.setattr(kubernetes_monitoring, "SNAPSHOT_EXPORT_DIR", tmp_path)
     path = kubernetes_monitoring._save_markdown_snapshot("hello world")
     assert path.parent == tmp_path
     assert path.read_text(encoding="utf-8") == "hello world\n"
 
 
-def test_save_markdown_snapshot_permission_error(monkeypatch):
+def test_save_markdown_snapshot_permission_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     """디렉터리 생성 실패 시 SnapshotSaveError 발생."""
 
     def fail_mkdir(*args, **kwargs):
@@ -164,7 +168,7 @@ def fail_mkdir(*args, **kwargs):
         kubernetes_monitoring._save_markdown_snapshot("data")
 
 
-def test_format_table_snapshot_uses_code_block():
+def test_format_table_snapshot_uses_code_block() -> None:
     """테이블 스냅샷이 코드블록 형태로 출력되는지 확인."""
     snapshot = kubernetes_monitoring._format_table_snapshot(
         title="Sample",
@@ -173,20 +177,23 @@ def test_format_table_snapshot_uses_code_block():
         command="kubectl get pods",
         status="success",
     )
-    assert snapshot.startswith("```text")
-    assert "| ---" not in snapshot
-    assert "| A |" not in snapshot
-    assert "Status: SUCCESS" in snapshot
-    assert "$ kubectl get pods" in snapshot
-    assert snapshot.endswith("```")
+    lines = snapshot.splitlines()
+    assert lines[0] == "*:white_check_mark: Sample*"
+    assert lines[1] == ""
+    assert lines[2] == "```"
+    assert "A  B" in lines[3]
+    assert "Command" not in snapshot
+    assert lines[-1] == "```"
 
 
 class _DummyLive:
     def __init__(self, console: Console) -> None:
         self.console = console
 
 
-def test_handle_snapshot_command_messages(monkeypatch, tmp_path):
+def test_handle_snapshot_command_messages(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
     """저장 명령 처리 시 사용자 입력을 메시지에 포함한다."""
     kubernetes_monitoring._clear_input_display()
     invalid_console = Console(record=True)
@@ -195,7 +202,7 @@ def test_handle_snapshot_command_messages(monkeypatch, tmp_path):
     mock_tracker.latest_snapshot = None
     mock_tracker.latest_structured_data = None
     kubernetes_monitoring._handle_snapshot_command(
-        invalid_live, mock_tracker, "invalid"
+        cast(Live, invalid_live), mock_tracker, "invalid"
     )
     text_output = invalid_console.export_text()
     assert "입력 'invalid' 은(는) 지원하지 않는 명령입니다." in text_output
@@ -212,11 +219,12 @@ def test_handle_snapshot_command_messages(monkeypatch, tmp_path):
     )
 
     captured_timestamps: Dict[str, Optional[str]] = {}
+    base_dir: Path = tmp_path
 
     def fake_save_markdown(markdown: str, timestamp: Optional[str] = None) -> Path:
         captured_timestamps["markdown"] = timestamp
         name = f"{timestamp or 'md-fallback'}.md"
-        target = tmp_path / name
+        target: Path = base_dir / name
         target.write_text(markdown, encoding="utf-8")
         return target
 
@@ -227,11 +235,11 @@ def fake_save_csv(
     ) -> Path:
         captured_timestamps["csv"] = timestamp
         name = f"{timestamp or 'csv-fallback'}.csv"
-        target = tmp_path / name
+        target: Path = base_dir / name
         with target.open("w", encoding="utf-8") as handle:
             handle.write(",".join(headers) + "\n")
             for row in rows:
-                handle.write(",".join(row) + "\n")
+                handle.write(",".join(str(value) for value in row) + "\n")
         return target
 
     monkeypatch.setattr(
@@ -252,15 +260,17 @@ def fake_save_csv(
         "headers": ["foo"],
         "rows": [["bar"]],
     }
-    kubernetes_monitoring._handle_snapshot_command(success_live, mock_tracker, ":save")
+    kubernetes_monitoring._handle_snapshot_command(
+        cast(Live, success_live), mock_tracker, ":save"
+    )
     text_output = success_console.export_text()
     assert "입력 ':save' 처리 성공" in text_output
     assert "스냅샷 저장 완료" in text_output
     assert "(CSV:" in text_output
     assert captured_timestamps["markdown"] == captured_timestamps["csv"]
 
 
-def test_live_frame_tracker_updates_sections():
+def test_live_frame_tracker_updates_sections() -> None:
     """LiveFrameTracker가 섹션별 프레임 키를 독립적으로 추적한다."""
     kubernetes_monitoring._clear_input_display()
     console = Console(record=True)
@@ -271,7 +281,7 @@ def test_live_frame_tracker_updates_sections():
         tracker.update(frame_key, renderable, snapshot_markdown=None, input_state="")
         assert tracker.section_frames["input"] == ("input", ("hidden", ""))
         assert tracker.section_frames["body"] == frame_key
-        assert tracker.section_frames["footer"] == ("footer", ("cmd-1",))
+        assert tracker.section_frames["footer"] is None
 
         renderable_updated = kubernetes_monitoring._compose_group(
             "cmd-2", Text("body-1")
@@ -280,4 +290,4 @@ def test_live_frame_tracker_updates_sections():
             frame_key, renderable_updated, snapshot_markdown=None, input_state=""
         )
         assert tracker.section_frames["body"] == frame_key
-        assert tracker.section_frames["footer"] == ("footer", ("cmd-2",))
+        assert tracker.section_frames["footer"] is None