ferp 0.7.1__py3-none-any.whl

ferp/core/task_store.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import json
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable, Iterable, Sequence
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+@dataclass(slots=True)
+class Task:
+    id: str
+    text: str
+    completed: bool = False
+    created_at: datetime = field(default_factory=_utcnow)
+    completed_at: datetime | None = None
+
+    def to_json(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "text": self.text,
+            "completed": self.completed,
+            "created_at": self.created_at.isoformat(),
+            "completed_at": self.completed_at.isoformat()
+            if self.completed_at
+            else None,
+        }
+
+    @classmethod
+    def from_json(cls, payload: dict[str, object]) -> Task:
+        created_at = payload.get("created_at")
+        completed_at = payload.get("completed_at")
+        return cls(
+            id=str(payload.get("id") or uuid.uuid4()),
+            text=str(payload.get("text") or "").strip(),
+            completed=bool(payload.get("completed", False)),
+            created_at=datetime.fromisoformat(created_at)
+            if isinstance(created_at, str)
+            else _utcnow(),
+            completed_at=datetime.fromisoformat(completed_at)
+            if isinstance(completed_at, str)
+            else None,
+        )
+
+
+class TaskStore:
+    """File-backed store for lightweight tasks."""
+
+    def __init__(self, storage_path: Path) -> None:
+        self.storage_path = storage_path
+        self.storage_path.parent.mkdir(parents=True, exist_ok=True)
+        self._tasks: list[Task] = []
+        self._listeners: set[Callable[[Sequence[Task]], None]] = set()
+        self.load()
+
+    def load(self) -> list[Task]:
+        if not self.storage_path.exists():
+            self._tasks = []
+            return []
+
+        try:
+            data = json.loads(self.storage_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            self._tasks = []
+            return []
+
+        if not isinstance(data, list):
+            self._tasks = []
+            return []
+
+        tasks: list[Task] = []
+        for raw in data:
+            if isinstance(raw, dict):
+                tasks.append(Task.from_json(raw))
+        self._tasks = tasks
+        return list(self._tasks)
+
+    def save(self) -> None:
+        payload = [task.to_json() for task in self._tasks]
+        self.storage_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+    def subscribe(self, callback: Callable[[Sequence[Task]], None]) -> None:
+        self._listeners.add(callback)
+        callback(tuple(self._tasks))
+
+    def unsubscribe(self, callback: Callable[[Sequence[Task]], None]) -> None:
+        self._listeners.discard(callback)
+
+    def _emit(self) -> None:
+        snapshot = tuple(self._tasks)
+        for callback in list(self._listeners):
+            callback(snapshot)
+
+    def all(self) -> list[Task]:
+        return list(self._tasks)
+
+    def sorted(self) -> list[Task]:
+        indexed = list(enumerate(self._tasks))
+        indexed.sort(key=lambda pair: (pair[1].completed, pair[0]))
+        return [task for _, task in indexed]
+
+    def add(self, text: str) -> Task:
+        normalized = text.strip()
+        if not normalized:
+            raise ValueError("Task text is required.")
+        new_task = Task(
+            id=str(uuid.uuid4()),
+            text=normalized,
+            completed=False,
+            created_at=_utcnow(),
+            completed_at=None,
+        )
+        self._tasks.append(new_task)
+        self.save()
+        self._emit()
+        return new_task
+
+    def delete(self, task_id: str) -> None:
+        before = len(self._tasks)
+        self._tasks = [task for task in self._tasks if task.id != task_id]
+        if len(self._tasks) != before:
+            self.save()
+            self._emit()
+
+    def update_text(self, task_id: str, new_text: str) -> Task | None:
+        normalized = new_text.strip()
+        if not normalized:
+            return None
+        for task in self._tasks:
+            if task.id == task_id:
+                task.text = normalized
+                self.save()
+                self._emit()
+                return task
+        return None
+
+    def toggle(self, task_id: str) -> Task | None:
+        for task in self._tasks:
+            if task.id == task_id:
+                task.completed = not task.completed
+                task.completed_at = _utcnow() if task.completed else None
+                self.save()
+                self._emit()
+                return task
+        return None
+
+    def clear_completed(self) -> None:
+        any_removed = any(task.completed for task in self._tasks)
+        if not any_removed:
+            return
+        self._tasks = [task for task in self._tasks if not task.completed]
+        self.save()
+        self._emit()
+
+    def import_tasks(self, tasks: Iterable[Task]) -> None:
+        """Replace the current list with provided tasks (used for testing)."""
+        self._tasks = list(tasks)
+        self.save()
+        self._emit()

ferp/core/transcript_logger.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Callable
+
+from ferp.core.script_runner import ScriptResult
+
+
+class TranscriptLogger:
+    """Writes script transcripts and prunes historical logs."""
+
+    def __init__(
+        self,
+        logs_dir: Path,
+        log_preferences: Callable[[], tuple[int, int]],
+    ) -> None:
+        self._logs_dir = logs_dir
+        self._logs_dir.mkdir(parents=True, exist_ok=True)
+        self._log_preferences = log_preferences
+
+    def write(
+        self,
+        script_name: str,
+        target_path: Path,
+        result: ScriptResult,
+    ) -> Path:
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+        slug = (
+            "".join(
+                ch.lower() if ch.isalnum() else "_" for ch in script_name.strip()
+            ).strip("_")
+            or "script"
+        )
+        filename = f"{timestamp}_{slug}.log"
+        path = self._logs_dir / filename
+
+        lines = [
+            f"Script: {script_name}",
+            f"Target: {target_path}",
+            f"Status: {result.status.value}",
+            f"Exit Code: {result.exit_code}",
+            "",
+            "Transcript:",
+        ]
+
+        for event in result.transcript:
+            if event.message:
+                payload = json.dumps(
+                    event.message.payload,
+                    ensure_ascii=False,
+                    indent=2,
+                )
+                lines.append(
+                    f"{event.direction.value.upper()} "
+                    f"{event.message.type.value}: {payload}"
+                )
+            elif event.raw:
+                lines.append(f"{event.direction.value.upper()}: {event.raw}")
+
+        path.write_text("\n".join(lines), encoding="utf-8")
+        self._prune()
+        return path
+
+    def _prune(self) -> None:
+        max_files, max_age_days = self._log_preferences()
+        entries = sorted(
+            self._logs_dir.glob("*.log"),
+            key=lambda item: item.stat().st_mtime,
+            reverse=True,
+        )
+
+        cutoff = None
+        if max_age_days > 0:
+            cutoff = datetime.now(timezone.utc) - timedelta(days=max_age_days)
+
+        for index, entry in enumerate(entries):
+            remove = index >= max_files
+            if not remove and cutoff is not None:
+                try:
+                    mtime = datetime.fromtimestamp(
+                        entry.stat().st_mtime,
+                        tz=timezone.utc,
+                    )
+                except (OSError, ValueError):
+                    mtime = None
+                if mtime is not None and mtime < cutoff:
+                    remove = True
+
+            if remove:
+                try:
+                    entry.unlink()
+                except OSError:
+                    pass

ferp/domain/scripts.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import List, Literal, Optional, TypedDict
+
+from typing_extensions import NotRequired
+
+TargetType = Literal[
+    "current_directory",
+    "highlighted_file",
+    "highlighted_directory",
+]
+
+
+class ScriptConfig(TypedDict):
+    id: str
+    name: str
+    version: str
+    script: str
+    target: TargetType
+    file_extensions: NotRequired[List[str]]
+
+
+@dataclass(frozen=True)
+class Script:
+    id: str
+    name: str
+    version: str
+    script: str
+    target: TargetType
+    file_extensions: Optional[List[str]] = None

ferp/fscp/host/__init__.py

@@ -0,0 +1,11 @@
+from .host import Host
+from .managed_process import ManagedProcess
+from .process_registry import ProcessMetadata, ProcessRecord, ProcessRegistry
+
+__all__ = [
+    "Host",
+    "ManagedProcess",
+    "ProcessMetadata",
+    "ProcessRecord",
+    "ProcessRegistry",
+]