newcode 0.1.1__py3-none-any.whl

code_puppy/scheduler/executor.py

@@ -0,0 +1,155 @@
+"""Task executor for the scheduler.
+
+Handles executing scheduled tasks by invoking code-puppy CLI
+with the configured prompt, model, and agent.
+"""
+
+import os
+import subprocess
+import sys
+from datetime import datetime
+from typing import Tuple
+
+from code_puppy.scheduler.config import (
+    SCHEDULER_LOG_DIR,
+    ScheduledTask,
+    update_task,
+)
+
+
+def get_code_puppy_command() -> str:
+    """Get the path to the code-puppy executable."""
+    # Try to find code-puppy in the same environment as this script
+    if sys.platform == "win32":
+        # On Windows, look for code-puppy.exe or use python -m
+        return "code-puppy"
+    else:
+        # On Unix, code-puppy should be in PATH if installed
+        return "code-puppy"
+
+
+def execute_task(task: ScheduledTask) -> Tuple[bool, int, str]:
+    """Execute a scheduled task.
+
+    Args:
+        task: The ScheduledTask to execute
+
+    Returns:
+        Tuple of (success: bool, exit_code: int, error_message: str)
+    """
+    # Ensure log directory exists
+    os.makedirs(SCHEDULER_LOG_DIR, mode=0o700, exist_ok=True)
+
+    # Build the command
+    cmd = [get_code_puppy_command()]
+
+    # Add prompt
+    cmd.extend(["-p", task.prompt])
+
+    # Add model if specified
+    if task.model:
+        cmd.extend(["--model", task.model])
+
+    # Add agent if specified
+    if task.agent:
+        cmd.extend(["--agent", task.agent])
+
+    # Determine working directory
+    working_dir = task.working_directory
+    if working_dir == "." or not working_dir:
+        working_dir = os.getcwd()
+    working_dir = os.path.expanduser(working_dir)
+
+    # Validate working directory exists
+    if not os.path.isdir(working_dir):
+        error_msg = f"Working directory not found: {working_dir}"
+        task.last_status = "failed"
+        task.last_exit_code = -1
+        update_task(task)
+        return (False, -1, error_msg)
+
+    # Ensure log file path
+    log_file = task.log_file
+    if not log_file:
+        log_file = os.path.join(SCHEDULER_LOG_DIR, f"{task.id}.log")
+    log_file = os.path.expanduser(log_file)
+
+    # Ensure log file directory exists
+    os.makedirs(os.path.dirname(log_file), exist_ok=True)
+
+    # Update task status to running
+    task.last_status = "running"
+    task.last_run = datetime.now().isoformat()
+    update_task(task)
+
+    try:
+        # Open log file for appending
+        with open(log_file, "a") as log_f:
+            # Write header
+            log_f.write(f"\n{'=' * 60}\n")
+            log_f.write(f"Task: {task.name} ({task.id})\n")
+            log_f.write(f"Started: {datetime.now().isoformat()}\n")
+            log_f.write(f"Command: {' '.join(cmd)}\n")
+            log_f.write(f"Working Dir: {working_dir}\n")
+            log_f.write(f"{'=' * 60}\n\n")
+            log_f.flush()
+
+            # Execute the command
+            process = subprocess.Popen(
+                cmd,
+                cwd=working_dir,
+                stdout=log_f,
+                stderr=subprocess.STDOUT,
+                shell=False,
+                env=os.environ.copy(),
+            )
+
+            # Wait for completion
+            exit_code = process.wait()
+
+            # Write footer
+            log_f.write(f"\n{'=' * 60}\n")
+            log_f.write(f"Finished: {datetime.now().isoformat()}\n")
+            log_f.write(f"Exit Code: {exit_code}\n")
+            log_f.write(f"{'=' * 60}\n")
+
+        # Update task status
+        task.last_status = "success" if exit_code == 0 else "failed"
+        task.last_exit_code = exit_code
+        update_task(task)
+
+        return (exit_code == 0, exit_code, "")
+
+    except FileNotFoundError as e:
+        error_msg = f"code-puppy not found: {e}"
+        task.last_status = "failed"
+        task.last_exit_code = -1
+        update_task(task)
+        return (False, -1, error_msg)
+
+    except Exception as e:
+        error_msg = f"Execution error: {e}"
+        task.last_status = "failed"
+        task.last_exit_code = -1
+        update_task(task)
+        return (False, -1, error_msg)
+
+
+def run_task_by_id(task_id: str) -> Tuple[bool, str]:
+    """Run a task immediately by its ID.
+
+    Returns:
+        Tuple of (success: bool, message: str)
+    """
+    from code_puppy.scheduler.config import get_task
+
+    task = get_task(task_id)
+    if not task:
+        return (False, f"Task not found: {task_id}")
+
+    success, exit_code, error = execute_task(task)
+
+    if success:
+        return (True, f"Task '{task.name}' completed successfully")
+    else:
+        return (False, f"Task '{task.name}' failed (exit code: {exit_code}): {error}")

code_puppy/scheduler/platform.py

@@ -0,0 +1,19 @@
+"""Platform abstraction for daemon management.
+
+Provides a unified interface for daemon operations across Windows, Linux, and macOS.
+"""
+
+import sys
+
+if sys.platform == "win32":
+    from code_puppy.scheduler.platform_win import (
+        is_process_running,
+        terminate_process,
+    )
+else:
+    from code_puppy.scheduler.platform_unix import (
+        is_process_running,
+        terminate_process,
+    )
+
+__all__ = ["is_process_running", "terminate_process"]

code_puppy/scheduler/platform_unix.py

@@ -0,0 +1,22 @@
+"""Unix/macOS platform support for scheduler daemon."""
+
+import os
+import signal
+
+
+def is_process_running(pid: int) -> bool:
+    """Check if a process with the given PID is running."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False
+
+
+def terminate_process(pid: int) -> bool:
+    """Terminate a process by PID."""
+    try:
+        os.kill(pid, signal.SIGTERM)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False

code_puppy/scheduler/platform_win.py

@@ -0,0 +1,32 @@
+"""Windows platform support for scheduler daemon."""
+
+import ctypes
+
+
+def is_process_running(pid: int) -> bool:
+    """Check if a process with the given PID is running."""
+    try:
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.OpenProcess(
+            0x1000, False, pid
+        )  # PROCESS_QUERY_LIMITED_INFORMATION
+        if handle:
+            kernel32.CloseHandle(handle)
+            return True
+        return False
+    except Exception:
+        return False
+
+
+def terminate_process(pid: int) -> bool:
+    """Terminate a process by PID."""
+    try:
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.OpenProcess(1, False, pid)  # PROCESS_TERMINATE
+        if handle:
+            kernel32.TerminateProcess(handle, 0)
+            kernel32.CloseHandle(handle)
+            return True
+        return False
+    except Exception:
+        return False

code_puppy/session_storage.py

@@ -0,0 +1,338 @@
+"""Shared helpers for persisting and restoring chat sessions.
+
+This module centralises the pickle + metadata handling that used to live in
+both the CLI command handler and the auto-save feature. Keeping it here helps
+us avoid duplication while staying inside the Zen-of-Python sweet spot: simple
+is better than complex, nested side effects are worse than deliberate helpers.
+"""
+
+from __future__ import annotations
+
+import json
+import pickle
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, List
+
+
+def _safe_loads(data: bytes) -> Any:
+    """Deserialize pickle data."""
+    return pickle.loads(data)  # noqa: S301
+
+
+_LEGACY_SIGNED_HEADER = b"CPSESSION\x01"
+_LEGACY_SIGNATURE_SIZE = (
+    32  # legacy signature bytes, retained only for backward-compat parsing
+)
+
+SessionHistory = List[Any]
+TokenEstimator = Callable[[Any], int]
+
+
+@dataclass(slots=True)
+class SessionPaths:
+    pickle_path: Path
+    metadata_path: Path
+
+
+@dataclass(slots=True)
+class SessionMetadata:
+    session_name: str
+    timestamp: str
+    message_count: int
+    total_tokens: int
+    pickle_path: Path
+    metadata_path: Path
+    auto_saved: bool = False
+
+    def as_serialisable(self) -> dict[str, Any]:
+        return {
+            "session_name": self.session_name,
+            "timestamp": self.timestamp,
+            "message_count": self.message_count,
+            "total_tokens": self.total_tokens,
+            "file_path": str(self.pickle_path),
+            "auto_saved": self.auto_saved,
+        }
+
+
+def _extract_pickle_payload(raw: bytes) -> bytes:
+    """Return the pickle payload from raw session file bytes.
+
+    New format is raw pickle bytes.
+    Legacy format was: header + 32-byte signature + pickle payload.
+    We no longer verify or generate signatures.
+    """
+    if raw.startswith(_LEGACY_SIGNED_HEADER):
+        offset = len(_LEGACY_SIGNED_HEADER) + _LEGACY_SIGNATURE_SIZE
+        return raw[offset:]
+    return raw
+
+
+def ensure_directory(path: Path) -> Path:
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def build_session_paths(base_dir: Path, session_name: str) -> SessionPaths:
+    pickle_path = base_dir / f"{session_name}.pkl"
+    metadata_path = base_dir / f"{session_name}_meta.json"
+    return SessionPaths(pickle_path=pickle_path, metadata_path=metadata_path)
+
+
+def save_session(
+    *,
+    history: SessionHistory,
+    session_name: str,
+    base_dir: Path,
+    timestamp: str,
+    token_estimator: TokenEstimator,
+    auto_saved: bool = False,
+) -> SessionMetadata:
+    ensure_directory(base_dir)
+    paths = build_session_paths(base_dir, session_name)
+
+    pickle_data = pickle.dumps(history)
+    tmp_pickle = paths.pickle_path.with_suffix(".tmp")
+    with tmp_pickle.open("wb") as pickle_file:
+        pickle_file.write(pickle_data)
+    tmp_pickle.replace(paths.pickle_path)
+
+    total_tokens = sum(token_estimator(message) for message in history)
+    metadata = SessionMetadata(
+        session_name=session_name,
+        timestamp=timestamp,
+        message_count=len(history),
+        total_tokens=total_tokens,
+        pickle_path=paths.pickle_path,
+        metadata_path=paths.metadata_path,
+        auto_saved=auto_saved,
+    )
+
+    tmp_metadata = paths.metadata_path.with_suffix(".tmp")
+    with tmp_metadata.open("w", encoding="utf-8") as metadata_file:
+        json.dump(metadata.as_serialisable(), metadata_file, indent=2)
+    tmp_metadata.replace(paths.metadata_path)
+
+    return metadata
+
+
+def load_session(
+    session_name: str, base_dir: Path, *, allow_legacy: bool = False
+) -> SessionHistory:
+    # Kept for API compatibility; legacy loading is always supported now.
+    _ = allow_legacy
+
+    paths = build_session_paths(base_dir, session_name)
+    if not paths.pickle_path.exists():
+        raise FileNotFoundError(paths.pickle_path)
+
+    raw = paths.pickle_path.read_bytes()
+    pickle_data = _extract_pickle_payload(raw)
+    return _safe_loads(pickle_data)
+
+
+def list_sessions(base_dir: Path) -> List[str]:
+    if not base_dir.exists():
+        return []
+    return sorted(path.stem for path in base_dir.glob("*.pkl"))
+
+
+def cleanup_sessions(base_dir: Path, max_sessions: int) -> List[str]:
+    if max_sessions <= 0:
+        return []
+
+    if not base_dir.exists():
+        return []
+
+    candidate_paths = list(base_dir.glob("*.pkl"))
+    if len(candidate_paths) <= max_sessions:
+        return []
+
+    sorted_candidates = sorted(
+        ((path.stat().st_mtime, path) for path in candidate_paths),
+        key=lambda item: item[0],
+    )
+
+    stale_entries = sorted_candidates[:-max_sessions]
+    removed_sessions: List[str] = []
+    for _, pickle_path in stale_entries:
+        metadata_path = base_dir / f"{pickle_path.stem}_meta.json"
+        try:
+            pickle_path.unlink(missing_ok=True)
+            metadata_path.unlink(missing_ok=True)
+            removed_sessions.append(pickle_path.stem)
+        except OSError:
+            continue
+
+    return removed_sessions
+
+
+async def restore_autosave_interactively(base_dir: Path) -> None:
+    """Prompt the user to load an autosave session from base_dir, if any exist.
+
+    This helper is deliberately placed in session_storage to keep autosave
+    restoration close to the persistence layer. It uses the same public APIs
+    (list_sessions, load_session) and mirrors the interactive behaviours from
+    the command handler.
+    """
+    sessions = list_sessions(base_dir)
+    if not sessions:
+        return
+
+    # Import locally to avoid pulling the messaging layer into storage modules
+    from datetime import datetime
+
+    from prompt_toolkit.formatted_text import FormattedText
+
+    from code_puppy.agents.agent_manager import get_current_agent
+    from code_puppy.command_line.prompt_toolkit_completion import (
+        get_input_with_combined_completion,
+    )
+    from code_puppy.messaging import emit_success, emit_system_message, emit_warning
+
+    entries = []
+    for name in sessions:
+        meta_path = base_dir / f"{name}_meta.json"
+        try:
+            with meta_path.open("r", encoding="utf-8") as meta_file:
+                data = json.load(meta_file)
+            timestamp = data.get("timestamp")
+            message_count = data.get("message_count")
+        except Exception:
+            timestamp = None
+            message_count = None
+        entries.append((name, timestamp, message_count))
+
+    def sort_key(entry):
+        _, timestamp, _ = entry
+        if timestamp:
+            try:
+                return datetime.fromisoformat(timestamp)
+            except ValueError:
+                return datetime.min
+        return datetime.min
+
+    entries.sort(key=sort_key, reverse=True)
+
+    PAGE_SIZE = 5
+    total = len(entries)
+    page = 0
+
+    def render_page() -> None:
+        start = page * PAGE_SIZE
+        end = min(start + PAGE_SIZE, total)
+        page_entries = entries[start:end]
+        emit_system_message("Autosave Sessions Available:")
+        for idx, (name, timestamp, message_count) in enumerate(page_entries, start=1):
+            timestamp_display = timestamp or "unknown time"
+            message_display = (
+                f"{message_count} messages"
+                if message_count is not None
+                else "unknown size"
+            )
+            emit_system_message(
+                f"  [{idx}] {name} ({message_display}, saved at {timestamp_display})"
+            )
+        # If there are more pages, offer next-page; show 'Return to first page' on last page
+        if total > PAGE_SIZE:
+            page_count = (total + PAGE_SIZE - 1) // PAGE_SIZE
+            is_last_page = (page + 1) >= page_count
+            remaining = total - (page * PAGE_SIZE + len(page_entries))
+            summary = (
+                f" and {remaining} more" if (remaining > 0 and not is_last_page) else ""
+            )
+            label = "Return to first page" if is_last_page else f"Next page{summary}"
+            emit_system_message(f"  [6] {label}")
+        emit_system_message("  [Enter] Skip loading autosave")
+
+    chosen_name: str | None = None
+
+    while True:
+        render_page()
+        try:
+            selection = await get_input_with_combined_completion(
+                FormattedText(
+                    [
+                        (
+                            "class:prompt",
+                            "Pick 1-5 to load, 6 for next, or name/Enter: ",
+                        )
+                    ]
+                )
+            )
+        except (KeyboardInterrupt, EOFError):
+            emit_warning("Autosave selection cancelled")
+            return
+
+        selection = (selection or "").strip()
+        if not selection:
+            return
+
+        # Numeric choice: 1-5 select within current page; 6 advances page
+        if selection.isdigit():
+            num = int(selection)
+            if num == 6 and total > PAGE_SIZE:
+                page = (page + 1) % ((total + PAGE_SIZE - 1) // PAGE_SIZE)
+                # loop and re-render next page
+                continue
+            if 1 <= num <= 5:
+                start = page * PAGE_SIZE
+                idx = start + (num - 1)
+                if 0 <= idx < total:
+                    chosen_name = entries[idx][0]
+                    break
+                else:
+                    emit_warning("Invalid selection for this page")
+                    continue
+            emit_warning("Invalid selection; choose 1-5 or 6 for next")
+            continue
+
+        # Allow direct typing by exact session name
+        for name, _ts, _mc in entries:
+            if name == selection:
+                chosen_name = name
+                break
+        if chosen_name:
+            break
+        emit_warning("No autosave loaded (invalid selection)")
+        # keep looping and allow another try
+
+    if not chosen_name:
+        return
+
+    try:
+        history = load_session(chosen_name, base_dir)
+    except FileNotFoundError:
+        emit_warning(f"Autosave '{chosen_name}' could not be found")
+        return
+    except Exception as exc:
+        emit_warning(f"Failed to load autosave '{chosen_name}': {exc}")
+        return
+
+    agent = get_current_agent()
+    agent.set_message_history(history)
+
+    # Set current autosave session id so subsequent autosaves overwrite this session
+    try:
+        from code_puppy.config import set_current_autosave_from_session_name
+
+        set_current_autosave_from_session_name(chosen_name)
+    except Exception:
+        pass
+
+    total_tokens = sum(agent.estimate_tokens_for_message(msg) for msg in history)
+
+    session_path = base_dir / f"{chosen_name}.pkl"
+    emit_success(
+        f"✅ Autosave loaded: {len(history)} messages ({total_tokens} tokens)\n"
+        f"📁 From: {session_path}"
+    )
+
+    # Display recent message history for context
+    try:
+        from code_puppy.command_line.autosave_menu import display_resumed_history
+
+        display_resumed_history(history)
+    except Exception:
+        pass  # Don't fail if display doesn't work in non-TTY environment