cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/task_reports.py

@@ -0,0 +1,287 @@
+"""
+CCT — task_reports.py: Structured Task Completion Reports (v0.7.10 spec #25).
+
+Provides structured reports when tasks complete, including:
+- Files changed
+- Tests run/pass/fail
+- Build status
+- Preview status
+- Todo progress
+- Duration
+- Any errors encountered
+
+These reports are shown in the chat as structured completion cards.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import os
+import time
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Any
+from enum import Enum
+
+
+class TaskStatus(Enum):
+    """Status of a completed task."""
+    SUCCESS = "success"
+    PARTIAL = "partial"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class TaskType(Enum):
+    """Type of task that was completed."""
+    BUILD = "build"
+    TEST = "test"
+    DEPLOY = "deploy"
+    FILE_WRITE = "file_write"
+    FILE_EDIT = "file_edit"
+    PACKAGE_INSTALL = "package_install"
+    AI_GENERATION = "ai_generation"
+    CUSTOM = "custom"
+
+
+@dataclass
+class FileChange:
+    """A file that was changed during the task."""
+    path: str
+    change_type: str  # "created", "modified", "deleted"
+    lines_added: int = 0
+    lines_removed: int = 0
+
+
+@dataclass
+class TestResult:
+    """Result of running tests."""
+    total: int = 0
+    passed: int = 0
+    failed: int = 0
+    skipped: int = 0
+    duration: float = 0.0
+    test_file: str = ""
+    error_message: str = ""
+
+
+@dataclass
+class BuildResult:
+    """Result of a build operation."""
+    success: bool = False
+    duration: float = 0.0
+    output: str = ""
+    error: str = ""
+    warnings: int = 0
+
+
+@dataclass
+class TaskReport:
+    """A structured report of a completed task."""
+    task_type: TaskType = TaskType.CUSTOM
+    status: TaskStatus = TaskStatus.SUCCESS
+    title: str = ""
+    description: str = ""
+
+    # Timing
+    start_time: float = field(default_factory=time.time)
+    end_time: float = 0.0
+    duration: float = 0.0
+
+    # Changes
+    files_changed: List[FileChange] = field(default_factory=list)
+
+    # Build/Test results
+    build_result: Optional[BuildResult] = None
+    test_result: Optional[TestResult] = None
+
+    # Preview
+    preview_url: str = ""
+    preview_active: bool = False
+
+    # Todo progress
+    todos_completed: int = 0
+    todos_total: int = 0
+
+    # Errors
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+
+    # Additional context
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def complete(self, status: TaskStatus = TaskStatus.SUCCESS):
+        """Mark the task as complete."""
+        self.end_time = time.time()
+        self.duration = self.end_time - self.start_time
+        self.status = status
+
+    def add_file_change(self, path: str, change_type: str,
+                        lines_added: int = 0, lines_removed: int = 0):
+        """Add a file change to the report."""
+        self.files_changed.append(FileChange(
+            path=path,
+            change_type=change_type,
+            lines_added=lines_added,
+            lines_removed=lines_removed
+        ))
+
+    def add_error(self, error: str):
+        """Add an error to the report."""
+        self.errors.append(error)
+        if self.status == TaskStatus.SUCCESS:
+            self.status = TaskStatus.PARTIAL
+
+    def add_warning(self, warning: str):
+        """Add a warning to the report."""
+        self.warnings.append(warning)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert report to dictionary for serialization."""
+        return {
+            "task_type": self.task_type.value,
+            "status": self.status.value,
+            "title": self.title,
+            "description": self.description,
+            "duration": self.duration,
+            "files_changed": [
+                {
+                    "path": fc.path,
+                    "change_type": fc.change_type,
+                    "lines_added": fc.lines_added,
+                    "lines_removed": fc.lines_removed,
+                }
+                for fc in self.files_changed
+            ],
+            "build_result": {
+                "success": self.build_result.success,
+                "duration": self.build_result.duration,
+                "warnings": self.build_result.warnings,
+            } if self.build_result else None,
+            "test_result": {
+                "total": self.test_result.total,
+                "passed": self.test_result.passed,
+                "failed": self.test_result.failed,
+                "duration": self.test_result.duration,
+            } if self.test_result else None,
+            "preview_url": self.preview_url,
+            "preview_active": self.preview_active,
+            "todos_completed": self.todos_completed,
+            "todos_total": self.todos_total,
+            "errors": self.errors,
+            "warnings": self.warnings,
+        }
+
+    def to_markdown(self) -> str:
+        """Convert report to markdown for chat display."""
+        lines = []
+
+        # Status icon
+        status_icons = {
+            TaskStatus.SUCCESS: "✓",
+            TaskStatus.PARTIAL: "⚠",
+            TaskStatus.FAILED: "✗",
+            TaskStatus.CANCELLED: "⊘",
+        }
+        icon = status_icons.get(self.status, "?")
+
+        # Title
+        lines.append(f"### {icon} {self.title}")
+        if self.description:
+            lines.append(f"{self.description}")
+        lines.append("")
+
+        # Duration
+        if self.duration > 0:
+            lines.append(f"**Duration:** {self.duration:.1f}s")
+
+        # Files changed
+        if self.files_changed:
+            lines.append(f"**Files changed:** {len(self.files_changed)}")
+            for fc in self.files_changed[:5]:  # Limit to 5 files
+                lines.append(f"- `{fc.path}` ({fc.change_type})")
+            if len(self.files_changed) > 5:
+                lines.append(f"- ... and {len(self.files_changed) - 5} more")
+
+        # Build result
+        if self.build_result:
+            status = "✓ passed" if self.build_result.success else "✗ failed"
+            lines.append(f"**Build:** {status} ({self.build_result.duration:.1f}s)")
+            if self.build_result.warnings:
+                lines.append(f"**Warnings:** {self.build_result.warnings}")
+
+        # Test result
+        if self.test_result:
+            lines.append(
+                f"**Tests:** {self.test_result.passed}/{self.test_result.total} passed"
+            )
+            if self.test_result.failed:
+                lines.append(f"**Failed:** {self.test_result.failed}")
+
+        # Preview
+        if self.preview_url:
+            lines.append(f"**Preview:** {self.preview_url}")
+
+        # Todo progress
+        if self.todos_total > 0:
+            lines.append(
+                f"**Todos:** {self.todos_completed}/{self.todos_total} completed"
+            )
+
+        # Errors
+        if self.errors:
+            lines.append("")
+            lines.append("**Errors:**")
+            for error in self.errors[:3]:
+                lines.append(f"- {error}")
+
+        # Warnings
+        if self.warnings:
+            lines.append("")
+            lines.append("**Warnings:**")
+            for warning in self.warnings[:3]:
+                lines.append(f"- {warning}")
+
+        return "\n".join(lines)
+
+
+class TaskReportManager:
+    """Manages task completion reports."""
+
+    def __init__(self):
+        self._reports = []
+        self._max_reports = 100
+
+    def create_report(self, task_type: TaskType, title: str,
+                      description: str = "") -> TaskReport:
+        """Create a new task report."""
+        report = TaskReport(
+            task_type=task_type,
+            title=title,
+            description=description,
+        )
+        self._reports.append(report)
+        if len(self._reports) > self._max_reports:
+            self._reports = self._reports[-self._max_reports:]
+        return report
+
+    def get_recent_reports(self, count: int = 10) -> List[TaskReport]:
+        """Get recent task reports."""
+        return self._reports[-count:]
+
+    def get_reports_by_type(self, task_type: TaskType) -> List[TaskReport]:
+        """Get reports filtered by task type."""
+        return [r for r in self._reports if r.task_type == task_type]
+
+
+# Global instance
+_task_report_manager = None
+
+
+def get_task_report_manager() -> TaskReportManager:
+    """Get or create the global task report manager."""
+    global _task_report_manager
+    if _task_report_manager is None:
+        _task_report_manager = TaskReportManager()
+    return _task_report_manager

calc_terminal/terminal_host.py

@@ -0,0 +1,201 @@
+"""
+CCT — terminal host detection + native clipboard read.
+
+CCT is a Textual chat IDE: it does not spawn or drive a shell/PTY, so a
+"paste" is delivered by the terminal the user launched CCT in. This
+module answers two questions the large-paste fix (v0.7.8.45) needs:
+
+  * Which shell is hosting CCT right now?       (detect_host)
+  * What does the clipboard actually hold on Windows?  (read_clipboard_text)
+
+The PowerShell case: on Windows console hosts (conhost / Windows
+Terminal, regardless of whether PowerShell or cmd is the shell), a very
+large bracketed-paste payload can be truncated or dropped while being
+written into the console input buffer — before Textual ever sees it.
+The paste handler recovers by comparing the delivered event text against
+the OS clipboard: when the clipboard is a strict prefix-superset of the
+delivered text, the clipboard is the authoritative payload.
+
+Everything here is best-effort; every function returns a safe default on
+failure so the app never depends on this module succeeding.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import os
+import sys
+import time
+
+_CF_UNICODETEXT = 13
+_cached_host = None
+_cached_emulator = None
+
+
+def detect_host():
+    """Lowercase name of the SHELL CCT is running inside:
+
+        'powershell' | 'cmd' | 'bash' | 'zsh' | 'other'
+
+    Detection is env-var based (no subprocesses, no psutil) and cached —
+    the environment cannot change at runtime. `CCT_FORCE_HOST` overrides
+    it for tests and exotic setups.
+    """
+    global _cached_host
+    forced = os.environ.get("CCT_FORCE_HOST", "").strip().lower()
+    if forced:
+        _cached_host = forced
+        return _cached_host
+    if _cached_host:
+        return _cached_host
+    host = "other"
+    try:
+        shell = os.environ.get("SHELL", "")
+        if shell:
+            base = os.path.basename(shell).lower()
+            if "zsh" in base:
+                host = "zsh"
+            elif "bash" in base or base in ("sh", "dash"):
+                host = "bash"
+        if host == "other" and os.environ.get("PSModulePath"):
+            # Set by Windows PowerShell and pwsh (and only by them), so
+            # it is the reliable PowerShell fingerprint on Windows.
+            host = "powershell"
+        if host == "other":
+            comspec = os.environ.get("COMSPEC", "").lower()
+            if "powershell" in comspec:
+                host = "powershell"
+            elif "cmd" in comspec:
+                host = "cmd"
+        if host == "other" and sys.platform == "win32":
+            host = "cmd"
+    except Exception:
+        host = "other"
+    _cached_host = host
+    return host
+
+
+def detect_emulator():
+    """Terminal-emulator name for diagnostics ('Windows Terminal',
+    'ConEmu', 'vscode', 'Apple Terminal', 'xterm', ...) or 'other'.
+    Never raises, cached."""
+    global _cached_emulator
+    if _cached_emulator:
+        return _cached_emulator
+    emu = "other"
+    try:
+        if os.environ.get("WT_SESSION"):
+            emu = "Windows Terminal"
+        elif os.environ.get("ConEmuPID"):
+            emu = "ConEmu"
+        elif os.environ.get("TERM_PROGRAM"):
+            tp = os.environ["TERM_PROGRAM"].lower()
+            emu = "vscode" if "vscode" in tp else os.environ["TERM_PROGRAM"]
+        elif os.environ.get("__CF_USER_TEXT_ENCODING"):
+            emu = "Apple Terminal"
+        elif os.environ.get("TERM"):
+            emu = os.environ["TERM"]
+    except Exception:
+        emu = "other"
+    _cached_emulator = emu
+    return emu
+
+
+def is_windows():
+    """True when CCT is running on a Windows console host (the only
+    place the clipboard-prefix paste recovery is needed)."""
+    return sys.platform == "win32"
+
+
+def read_clipboard_text():
+    """Best-effort native clipboard read on Windows (user32
+    GetClipboardData, CF_UNICODETEXT via ctypes — no third-party
+    dependency, no subprocess). Returns the clipboard text as str, or
+    None when there is no text / the clipboard is busy / an error
+    occurs / the platform is not Windows."""
+    if sys.platform != "win32":
+        return None
+    try:
+        import ctypes
+        from ctypes import wintypes
+        user32 = ctypes.windll.user32
+        kernel32 = ctypes.windll.kernel32
+        # Restype/argtype declarations are mandatory: the default int
+        # restype truncates 64-bit HGLOBAL pointers returned by
+        # GetClipboardData/GlobalLock/GlobalSize.
+        user32.IsClipboardFormatAvailable.argtypes = [wintypes.UINT]
+        user32.IsClipboardFormatAvailable.restype = wintypes.BOOL
+        user32.GetClipboardData.argtypes = [wintypes.UINT]
+        user32.GetClipboardData.restype = ctypes.c_void_p
+        kernel32.GlobalSize.argtypes = [ctypes.c_void_p]
+        kernel32.GlobalSize.restype = ctypes.c_size_t
+        kernel32.GlobalLock.argtypes = [ctypes.c_void_p]
+        kernel32.GlobalLock.restype = ctypes.c_void_p
+        kernel32.GlobalUnlock.argtypes = [ctypes.c_void_p]
+        kernel32.GlobalUnlock.restype = wintypes.BOOL
+        text = None
+        for _ in range(3):  # brief retries; the clipboard is often held
+            if user32.OpenClipboard(None):
+                break
+            time.sleep(0.015)
+        else:
+            return None
+        try:
+            if not user32.IsClipboardFormatAvailable(_CF_UNICODETEXT):
+                return None
+            handle = user32.GetClipboardData(_CF_UNICODETEXT)
+            if not handle:
+                return None
+            ptr = kernel32.GlobalLock(handle)
+            if not ptr:
+                return None
+            try:
+                size = kernel32.GlobalSize(handle)
+                if size <= 2:
+                    return None
+                nchars = size // 2
+                arr = (ctypes.c_wchar * (nchars + 1)).from_address(ptr)
+                text = "".join(arr[:nchars]).rstrip("\x00")
+            finally:
+                kernel32.GlobalUnlock(handle)
+        finally:
+            user32.CloseClipboard()
+        return text
+    except Exception:
+        return None
+
+
+def clipboard_payload_override(delivered):
+    """Windows paste-recovery decision (v0.7.8.45, PowerShell case).
+
+    Returns (payload, source) for the paste handler:
+
+      (delivered, 'terminal')                  — keep what the terminal
+                                                 delivered (everything
+                                                 else)
+      (clipboard, 'clipboard')                 — the Windows console
+                                                 host truncated the
+                                                 bracketed-paste payload
+                                                 (clipboard is a strict
+                                                 prefix-superset of the
+                                                 delivered text), so the
+                                                 clipboard is the
+                                                 authoritative copy
+
+    `source` is the human-readable name used in debug logs.
+    """
+    if not is_windows():
+        return delivered, "terminal"
+    if not delivered:
+        # Host dropped the whole payload; the clipboard is the only
+        # copy left.
+        clip = read_clipboard_text()
+        if clip:
+            return clip, "clipboard (terminal dropped the payload)"
+        return delivered, "terminal"
+    clip = read_clipboard_text()
+    if clip and len(clip) > len(delivered) and clip.startswith(delivered):
+        return clip, "clipboard (terminal payload truncated)"
+    return delivered, "terminal"