patchfeld 0.2.0__py3-none-any.whl

patchfeld/persistence/agents_index.py

@@ -0,0 +1,68 @@
+import json
+import logging
+import time
+from pathlib import Path
+
+from patchfeld.agents.state import AgentInfo, AgentState
+from patchfeld.persistence.atomic import write_json_atomic
+from patchfeld.persistence.paths import project_state_dir
+
+log = logging.getLogger(__name__)
+
+
+def _index_path(cwd: Path) -> Path:
+    return project_state_dir(cwd) / "agents.json"
+
+
+class AgentsIndex:
+    def __init__(self, cwd: Path) -> None:
+        self._cwd = cwd
+        self._path = _index_path(cwd)
+
+    def load(self) -> list[AgentInfo]:
+        if not self._path.exists():
+            return []
+        try:
+            raw = json.loads(self._path.read_text(encoding="utf-8"))
+            if not isinstance(raw, list):
+                log.warning("agents.json is not a list at %s", self._path)
+                return []
+            return [AgentInfo.from_dict(entry) for entry in raw]
+        except Exception:
+            log.exception("Failed to load agents.json from %s", self._path)
+            return []
+
+    def save(self, infos: list[AgentInfo]) -> None:
+        write_json_atomic(self._path, [info.to_dict() for info in infos])
+
+    def upsert(self, info: AgentInfo) -> None:
+        current = self.load()
+        for i, existing in enumerate(current):
+            if existing.id == info.id:
+                current[i] = info
+                self.save(current)
+                return
+        current.append(info)
+        self.save(current)
+
+    def reconcile_orphans(self) -> list[AgentInfo]:
+        # On boot the manager has no live sessions yet, so any persisted
+        # agent in a non-terminal state is from a previous process that died
+        # without marking it done (e.g. crash). Flip it to ERROR so the table
+        # doesn't claim those rows are still running.
+        # The orchestrator is excluded — it owns its own boot lifecycle and
+        # will overwrite the entry on start().
+        infos = self.load()
+        now = time.time()
+        changed = False
+        for info in infos:
+            if info.id == "orchestrator":
+                continue
+            if not info.state.is_terminal:
+                info.state = AgentState.ERROR
+                if info.ended_at is None:
+                    info.ended_at = now
+                changed = True
+        if changed:
+            self.save(infos)
+        return infos

patchfeld/persistence/atomic.py

@@ -0,0 +1,47 @@
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+
+def write_json_atomic(path: Path, data: Any) -> None:
+    """Write JSON to `path` atomically: write to a temp file in the same
+    directory, fsync, then rename. Same-directory rename is atomic on POSIX.
+    Parent directories are created if missing."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    fd, tmp_name = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp",
+                                    dir=str(path.parent))
+    tmp_path = Path(tmp_name)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    except Exception:
+        tmp_path.unlink(missing_ok=True)
+        raise
+
+
+def write_text_atomic(path: Path, text: str) -> None:
+    """Write `text` to `path` atomically: write to a temp file in the same
+    directory, fsync, then rename. Same-directory rename is atomic on POSIX.
+    Parent directories are created if missing."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    fd, tmp_name = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp",
+                                    dir=str(path.parent))
+    tmp_path = Path(tmp_name)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(text)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    except Exception:
+        tmp_path.unlink(missing_ok=True)
+        raise

patchfeld/persistence/layout_store.py

@@ -0,0 +1,25 @@
+import json
+import logging
+from pathlib import Path
+
+from patchfeld.layout.spec import LayoutSpec
+from patchfeld.persistence.atomic import write_json_atomic
+from patchfeld.persistence.paths import project_layout_path
+
+log = logging.getLogger(__name__)
+
+
+def save_layout(cwd: Path, spec: LayoutSpec) -> None:
+    write_json_atomic(project_layout_path(cwd), spec.model_dump(mode="json"))
+
+
+def load_layout(cwd: Path) -> LayoutSpec | None:
+    path = project_layout_path(cwd)
+    if not path.exists():
+        return None
+    try:
+        raw = json.loads(path.read_text())
+        return LayoutSpec.model_validate(raw)
+    except Exception:
+        log.exception("Failed to load layout from %s", path)
+        return None

patchfeld/persistence/layouts_store.py

@@ -0,0 +1,61 @@
+import json
+import logging
+import re
+from pathlib import Path
+
+from patchfeld.layout.spec import LayoutSpec
+from patchfeld.persistence.atomic import write_json_atomic
+
+log = logging.getLogger(__name__)
+
+_VALID_NAME = re.compile(r"^[A-Za-z0-9_\-]+$")
+
+
+class NamedLayoutsStore:
+    """Read/write named LayoutSpecs at <global_dir>/layouts/<name>.json."""
+
+    def __init__(self, global_dir: Path) -> None:
+        self._dir = Path(global_dir) / "layouts"
+
+    def save(self, name: str, spec: LayoutSpec) -> None:
+        if not name or not _VALID_NAME.match(name):
+            raise ValueError(
+                f"layout name must match {_VALID_NAME.pattern!r}, got {name!r}"
+            )
+        write_json_atomic(self._dir / f"{name}.json", spec.model_dump(mode="json"))
+
+    def load(self, name: str) -> LayoutSpec | None:
+        path = self._dir / f"{name}.json"
+        if not path.exists():
+            return None
+        try:
+            return LayoutSpec.model_validate(json.loads(path.read_text(encoding="utf-8")))
+        except Exception:
+            log.exception("Failed to load named layout %r", name)
+            return None
+
+    def list(self) -> list[str]:
+        if not self._dir.exists():
+            return []
+        names = []
+        for p in self._dir.iterdir():
+            if p.is_file() and p.suffix == ".json":
+                names.append(p.stem)
+        return sorted(names)
+
+    def delete(self, name: str) -> bool:
+        """Remove the named layout's JSON file. Returns True if a file was
+        removed, False if no such file existed. Raises ValueError on names
+        that don't match the same charset enforced by `save()` — this guards
+        against any caller smuggling in `..` segments or path separators.
+        """
+        if not name or not _VALID_NAME.match(name):
+            raise ValueError(
+                f"layout name must match {_VALID_NAME.pattern!r}, got {name!r}"
+            )
+        path = self._dir / f"{name}.json"
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            return False
+        return True

patchfeld/persistence/orchestrator_sessions.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import asdict, dataclass, fields
+from pathlib import Path
+
+from patchfeld.persistence.atomic import write_json_atomic
+from patchfeld.persistence.paths import project_state_dir
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class OrchestratorSessionEntry:
+    session_id: str
+    transcript_path: str
+    started_at: float
+    last_activity: float
+    first_user_message: str | None = None
+    title: str | None = None  # explicit title; defaults to first_user_message-derived
+    num_turns: int = 0
+    tokens_in: int = 0
+    tokens_out: int = 0
+    cost: float = 0.0
+    legacy: bool = False
+
+
+def _index_path(cwd: Path) -> Path:
+    return project_state_dir(cwd) / "orchestrator_sessions.json"
+
+
+class OrchestratorSessionsIndex:
+    """Per-cwd index of past orchestrator sessions for resume/picker."""
+
+    def __init__(self, cwd: Path) -> None:
+        self._cwd = cwd
+        self._path = _index_path(cwd)
+
+    def list(self) -> list[OrchestratorSessionEntry]:
+        if not self._path.exists():
+            return []
+        try:
+            raw = json.loads(self._path.read_text(encoding="utf-8"))
+            if not isinstance(raw, list):
+                log.warning("orchestrator_sessions.json is not a list at %s", self._path)
+                return []
+            valid = {f.name for f in fields(OrchestratorSessionEntry)}
+            out: list[OrchestratorSessionEntry] = []
+            for item in raw:
+                if not isinstance(item, dict):
+                    continue
+                kwargs = {k: v for k, v in item.items() if k in valid}
+                out.append(OrchestratorSessionEntry(**kwargs))
+            return out
+        except Exception:
+            log.exception("Failed to load orchestrator_sessions.json from %s", self._path)
+            return []
+
+    def upsert(self, entry: OrchestratorSessionEntry) -> None:
+        current = self.list()
+        for i, existing in enumerate(current):
+            if existing.session_id == entry.session_id:
+                current[i] = entry
+                self._save(current)
+                return
+        current.append(entry)
+        self._save(current)
+
+    def most_recent(self) -> OrchestratorSessionEntry | None:
+        entries = self.list()
+        if not entries:
+            return None
+        return max(entries, key=lambda e: e.last_activity)
+
+    def get(self, session_id: str) -> OrchestratorSessionEntry | None:
+        for e in self.list():
+            if e.session_id == session_id:
+                return e
+        return None
+
+    def set_title(self, session_id: str, title: str | None) -> bool:
+        """Update an entry's title. Returns True if the entry was found."""
+        entry = self.get(session_id)
+        if entry is None:
+            return False
+        entry.title = title
+        self.upsert(entry)
+        return True
+
+    def migrate_legacy_if_needed(self) -> None:
+        """One-time migration: rename .patchfeld/transcripts/orchestrator.jsonl
+        to orchestrator.legacy-<ts>.jsonl and register a legacy=True entry.
+
+        No-op if the index already has any entries OR if no legacy file exists.
+        """
+        from patchfeld.persistence.paths import project_transcripts_dir
+
+        if self._path.exists():
+            return  # index already exists — don't touch
+
+        legacy_path = project_transcripts_dir(self._cwd) / "orchestrator.jsonl"
+        if not legacy_path.exists():
+            return
+
+        mtime = legacy_path.stat().st_mtime
+        legacy_id = f"legacy-{int(mtime)}"
+        new_path = project_transcripts_dir(self._cwd) / f"orchestrator.{legacy_id}.jsonl"
+        legacy_path.rename(new_path)
+
+        entry = OrchestratorSessionEntry(
+            session_id=legacy_id,
+            transcript_path=str(new_path.relative_to(self._cwd))
+                if new_path.is_relative_to(self._cwd) else str(new_path),
+            started_at=mtime,
+            last_activity=mtime,
+            first_user_message=None,
+            num_turns=0,
+            tokens_in=0,
+            tokens_out=0,
+            cost=0.0,
+            legacy=True,
+        )
+        self.upsert(entry)
+
+    def _save(self, entries: list[OrchestratorSessionEntry]) -> None:
+        write_json_atomic(self._path, [asdict(e) for e in entries])

patchfeld/persistence/paths.py

@@ -0,0 +1,48 @@
+import os
+from pathlib import Path
+
+
+def project_state_dir(cwd: Path) -> Path:
+    return Path(cwd) / ".patchfeld"
+
+
+def project_layout_path(cwd: Path) -> Path:
+    return project_state_dir(cwd) / "layout.json"
+
+
+def project_workspace_path(cwd: Path) -> Path:
+    return project_state_dir(cwd) / "workspace.json"
+
+
+def project_transcripts_dir(cwd: Path) -> Path:
+    return project_state_dir(cwd) / "transcripts"
+
+
+def project_transcript_path(cwd: Path, agent_id: str) -> Path:
+    return project_transcripts_dir(cwd) / f"{agent_id}.jsonl"
+
+
+def project_orchestrator_transcript(cwd: Path) -> Path:
+    return project_transcripts_dir(cwd) / "orchestrator.jsonl"
+
+
+def orchestrator_session_transcript_path(cwd: Path, session_id: str) -> Path:
+    return project_transcripts_dir(cwd) / f"orchestrator.{session_id}.jsonl"
+
+
+def global_config_dir() -> Path:
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    if xdg:
+        return Path(xdg) / "patchfeld"
+    return Path.home() / ".config" / "patchfeld"
+
+
+def local_widgets_dir(global_dir: Path | None = None) -> Path:
+    """Return the directory where user-authored custom widgets live.
+
+    With `global_dir` provided, returns `<global_dir>/widgets/` — useful for
+    tests that pin a per-tmp_path config root. Without it, derives from
+    `global_config_dir()` (which honors `XDG_CONFIG_HOME`).
+    """
+    base = Path(global_dir) if global_dir else global_config_dir()
+    return base / "widgets"

patchfeld/persistence/themes_store.py

@@ -0,0 +1,44 @@
+import json
+import logging
+import re
+from pathlib import Path
+
+from patchfeld.persistence.atomic import write_json_atomic
+from patchfeld.theme.spec import ThemeSpec
+
+log = logging.getLogger(__name__)
+
+_VALID_NAME = re.compile(r"^[A-Za-z0-9_\-]+$")
+
+
+class NamedThemesStore:
+    """Read/write named ThemeSpecs at <global_dir>/themes/<name>.json."""
+
+    def __init__(self, global_dir: Path) -> None:
+        self._dir = Path(global_dir) / "themes"
+
+    def save(self, name: str, spec: ThemeSpec) -> None:
+        if not name or not _VALID_NAME.match(name):
+            raise ValueError(
+                f"theme name must match {_VALID_NAME.pattern!r}, got {name!r}"
+            )
+        write_json_atomic(self._dir / f"{name}.json", spec.model_dump(mode="json"))
+
+    def load(self, name: str) -> ThemeSpec | None:
+        path = self._dir / f"{name}.json"
+        if not path.exists():
+            return None
+        try:
+            return ThemeSpec.model_validate(json.loads(path.read_text(encoding="utf-8")))
+        except Exception:
+            log.exception("Failed to load named theme %r", name)
+            return None
+
+    def list(self) -> list[str]:
+        if not self._dir.exists():
+            return []
+        names = []
+        for p in self._dir.iterdir():
+            if p.is_file() and p.suffix == ".json":
+                names.append(p.stem)
+        return sorted(names)

patchfeld/persistence/transcript_store.py

@@ -0,0 +1,64 @@
+import json
+import logging
+from dataclasses import asdict, dataclass, fields
+from pathlib import Path
+
+from patchfeld.persistence.paths import project_transcript_path
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class TranscriptEntry:
+    role: str  # "user" | "assistant" | "tool_use" | "tool_result" | "thinking" | "system" | "orch"
+    text: str
+    tool_id: str | None = None
+    tool_name: str | None = None
+
+
+class AgentTranscript:
+    """Append-only JSONL transcript for one agent.
+
+    Use agent_id="orchestrator" for the orchestrator's own transcript;
+    `OrchestratorTranscript` is provided as a thin alias for that case
+    so plan-1 callers don't have to change.
+    """
+
+    def __init__(
+        self,
+        cwd: Path,
+        agent_id: str,
+        *,
+        path: Path | None = None,
+    ) -> None:
+        self._cwd = cwd
+        self._agent_id = agent_id
+        self._path = Path(path) if path is not None else project_transcript_path(cwd, agent_id)
+
+    def append(self, entry: TranscriptEntry) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        with self._path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(asdict(entry)) + "\n")
+
+    def read_all(self) -> list[TranscriptEntry]:
+        if not self._path.exists():
+            return []
+        out: list[TranscriptEntry] = []
+        valid_keys = {f.name for f in fields(TranscriptEntry)}
+        for line in self._path.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            try:
+                raw = json.loads(line)
+                kwargs = {k: v for k, v in raw.items() if k in valid_keys}
+                out.append(TranscriptEntry(**kwargs))
+            except Exception:
+                log.warning("Skipping corrupted transcript line: %r", line)
+        return out
+
+
+class OrchestratorTranscript(AgentTranscript):
+    """Plan-1 alias for AgentTranscript(agent_id='orchestrator')."""
+
+    def __init__(self, cwd: Path) -> None:
+        super().__init__(cwd=cwd, agent_id="orchestrator")

patchfeld/persistence/workspace_store.py

@@ -0,0 +1,25 @@
+import json
+import logging
+from pathlib import Path
+
+from patchfeld.persistence.atomic import write_json_atomic
+from patchfeld.persistence.paths import project_workspace_path
+from patchfeld.workspace.spec import Workspace
+
+log = logging.getLogger(__name__)
+
+
+def save_workspace(cwd: Path, ws: Workspace) -> None:
+    write_json_atomic(project_workspace_path(cwd), ws.model_dump(mode="json"))
+
+
+def load_workspace(cwd: Path) -> Workspace | None:
+    path = project_workspace_path(cwd)
+    if not path.exists():
+        return None
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+        return Workspace.model_validate(raw)
+    except Exception:
+        log.exception("Failed to load workspace from %s", path)
+        return None

patchfeld/theme/engine.py

@@ -0,0 +1,75 @@
+"""Apply a ThemeSpec to a live Textual App.
+
+apply_theme() is the single seam every theme-load path goes through:
+    - the load_theme orchestrator tool,
+    - the theme switcher modal,
+    - boot-time apply.
+
+The function is idempotent under same-name re-apply.
+"""
+from textual.app import App
+from textual.css.tokenize import tokenize
+from textual.theme import Theme
+
+from patchfeld.theme.spec import ThemePalette, ThemeSpec
+
+_EXTRA_CSS_KEY = ("patchfeld_theme", "extra_css")
+_THEME_NAME_PREFIX = "patchfeld:"
+
+
+def palette_from_textual_theme(textual_theme) -> ThemePalette:
+    """Snapshot a live textual.theme.Theme into our ThemePalette."""
+    return ThemePalette(
+        primary=textual_theme.primary,
+        secondary=textual_theme.secondary,
+        warning=textual_theme.warning,
+        error=textual_theme.error,
+        success=textual_theme.success,
+        accent=textual_theme.accent,
+        foreground=textual_theme.foreground,
+        background=textual_theme.background,
+        surface=textual_theme.surface,
+        panel=textual_theme.panel,
+        boost=textual_theme.boost,
+        dark=textual_theme.dark,
+        luminosity_spread=textual_theme.luminosity_spread,
+        text_alpha=textual_theme.text_alpha,
+        variables=dict(textual_theme.variables),
+    )
+
+
+async def apply_theme(app: App, spec: ThemeSpec, *, theme_name: str) -> None:
+    """Register/update the theme, set it active, and (re)install extra_css.
+
+    Order of operations: validate everything that can fail BEFORE mutating
+    app.theme. If anything raises, the previous theme stays active.
+    """
+    # 1. Pre-validate extra_css by tokenizing it on the raw tokenizer.
+    #    This catches structural/syntax errors (e.g. unclosed braces) without
+    #    trying to resolve $variables — which are theme-time, not parse-time.
+    if spec.extra_css:
+        list(tokenize(spec.extra_css, _EXTRA_CSS_KEY))  # raises TokenError on bad syntax
+
+    # 2. Build the Textual Theme. Will raise on bad color strings.
+    # Note: palette validation is best-effort — Textual accepts color strings opaquely.
+    full_name = f"{_THEME_NAME_PREFIX}{theme_name}"
+    theme = Theme(name=full_name, **spec.palette.model_dump())
+
+    # 3. Replace any prior registration for this name. register_theme would
+    #    raise on duplicate, and we want re-apply to mean "swap in place."
+    if full_name in app.available_themes:
+        app.unregister_theme(full_name)
+
+    # 4. Register and activate. Reactive watcher refreshes $primary etc.
+    app.register_theme(theme)
+    app.theme = full_name
+
+    # 5. Swap the named CSS source.
+    if _EXTRA_CSS_KEY in app.stylesheet.source:
+        del app.stylesheet.source[_EXTRA_CSS_KEY]
+    if spec.extra_css:
+        app.stylesheet.add_source(spec.extra_css, read_from=_EXTRA_CSS_KEY)
+    app.refresh_css()
+
+    # 6. Cache the applied extra_css for snapshotting (save_theme).
+    app._active_theme_extra_css = spec.extra_css

patchfeld/theme/spec.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ThemePalette(BaseModel):
+    """Maps 1:1 to textual.theme.Theme constructor args."""
+    model_config = ConfigDict(extra="forbid")
+
+    primary: str
+    secondary: str | None = None
+    warning: str | None = None
+    error: str | None = None
+    success: str | None = None
+    accent: str | None = None
+    foreground: str | None = None
+    background: str | None = None
+    surface: str | None = None
+    panel: str | None = None
+    boost: str | None = None
+    dark: bool = True
+    luminosity_spread: float = 0.15
+    text_alpha: float = 0.95
+    variables: dict[str, str] = Field(default_factory=dict)
+
+
+class ThemeSpec(BaseModel):
+    """Saved theme. Applied to a live App via theme.engine.apply_theme."""
+    model_config = ConfigDict(extra="forbid")
+
+    version: int = 1
+    palette: ThemePalette
+    extra_css: str = ""

patchfeld/widgets/_file_lang.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+
+_EXTENSION_LANGUAGES = {
+    ".py": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "javascript",  # TextArea ships JS lexer; TS falls back well.
+    ".tsx": "javascript",
+    ".json": "json",
+    ".html": "html",
+    ".css": "css",
+    ".md": "markdown",
+    ".rs": "rust",
+    ".go": "go",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".sql": "sql",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+}
+
+
+def detect_language(path: Path) -> str | None:
+    return _EXTENSION_LANGUAGES.get(path.suffix.lower())
+
+
+def load_text(path: Path) -> tuple[str, str | None]:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        text = f"File not found: {path}"
+    except Exception as e:
+        text = f"Error loading {path}: {e}"
+    return text, detect_language(path)