agent-notes 2.0.4__py3-none-any.whl

agent_notes/services/state_store.py

@@ -0,0 +1,249 @@
+"""State storage I/O operations."""
+
+from __future__ import annotations
+
+import os
+import json
+import hashlib
+from pathlib import Path
+from dataclasses import asdict
+from typing import Optional
+from datetime import datetime, timezone
+
+from ..domain.state import State, ScopeState, BackendState, InstalledItem, MemoryConfig
+
+
+def state_dir() -> Path:
+    """~/.config/agent-notes/ respecting $XDG_CONFIG_HOME."""
+    config_home = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(config_home) if config_home else (Path.home() / ".config")
+    return base / "agent-notes"
+
+
+def state_file() -> Path:
+    return state_dir() / "state.json"
+
+
+def load_state() -> Optional[State]:
+    """Load state from disk. Return None if file absent or on any error."""
+    file_path = state_file()
+    if not file_path.exists():
+        return None
+    
+    try:
+        data = json.loads(file_path.read_text())
+        state = _state_from_dict(data)
+        return state
+    except Exception:
+        return None
+
+
+def save_state(state: State) -> None:
+    """Atomic write. Updates updated_at on any ScopeState that has changed — but
+    caller is responsible for setting installed_at on first creation. `save_state` itself
+    refreshes `updated_at` on ALL present scopes (simple semantics).
+    
+    Serialize as JSON with keys:
+      source_path, source_commit, global, local
+    
+    - `global_install` serializes to key "global" (None → omit or null)
+    - `local_installs` serializes to key "local"
+    - `BackendState.role_models` and `BackendState.installed` serialize naturally
+    - `installed[component_type]` is a dict of name → InstalledItem as dict
+    """
+    # Update timestamps on all scopes
+    now = now_iso()
+    if state.global_install:
+        state.global_install.updated_at = now
+    for scope_state in state.local_installs.values():
+        scope_state.updated_at = now
+    
+    # Ensure directory exists
+    file_path = state_file()
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Convert to JSON-serializable dict
+    data = _state_to_dict(state)
+    
+    # Atomic write
+    tmp_path = file_path.with_suffix(".json.tmp")
+    try:
+        tmp_path.write_text(json.dumps(data, indent=2))
+        os.replace(tmp_path, file_path)
+    except Exception:
+        # Cleanup on failure
+        if tmp_path.exists():
+            tmp_path.unlink()
+        raise
+
+
+def clear_state() -> None:
+    """Delete state file. No error if absent."""
+    file_path = state_file()
+    if file_path.exists():
+        file_path.unlink()
+
+
+def get_scope(state: State, scope: str, project_path: Optional[Path] = None) -> Optional[ScopeState]:
+    """Fetch the ScopeState for a scope. scope is 'global' or 'local'.
+    For 'local', project_path MUST be provided (absolute path).
+    Returns None if the scope hasn't been installed to yet."""
+    if scope == "global":
+        return state.global_install
+    if scope == "local":
+        if project_path is None:
+            raise ValueError("project_path required for local scope")
+        return state.local_installs.get(str(Path(project_path).resolve()))
+    raise ValueError(f"Unknown scope: {scope}")
+
+
+def set_scope(state: State, scope: str, scope_state: ScopeState, project_path: Optional[Path] = None) -> None:
+    """Set/replace the scope state."""
+    if scope == "global":
+        state.global_install = scope_state
+    elif scope == "local":
+        if project_path is None:
+            raise ValueError("project_path required for local scope")
+        state.local_installs[str(Path(project_path).resolve())] = scope_state
+    else:
+        raise ValueError(f"Unknown scope: {scope}")
+
+
+def remove_scope(state: State, scope: str, project_path: Optional[Path] = None) -> None:
+    """Remove scope state (for uninstall)."""
+    if scope == "global":
+        state.global_install = None
+    elif scope == "local":
+        if project_path is None:
+            raise ValueError("project_path required for local scope")
+        state.local_installs.pop(str(Path(project_path).resolve()), None)
+
+
+def default_state() -> State:
+    """Create an empty state."""
+    return State(
+        source_path="",
+        source_commit="",
+        global_install=None,
+        local_installs={}
+    )
+
+
+def sha256_of(path: Path) -> str:
+    """Return sha256 hex digest of a file's bytes."""
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def now_iso() -> str:
+    """Current UTC ISO 8601 timestamp, seconds precision, trailing Z."""
+    return datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
+
+
+def _state_to_dict(s: State) -> dict:
+    return {
+        "source_path": s.source_path,
+        "source_commit": s.source_commit,
+        "global": _scope_to_dict(s.global_install) if s.global_install else None,
+        "local": {path: _scope_to_dict(ss) for path, ss in s.local_installs.items()},
+        "memory": {"backend": s.memory.backend, "path": s.memory.path},
+    }
+
+
+def _scope_to_dict(s: ScopeState) -> dict:
+    return {
+        "installed_at": s.installed_at,
+        "updated_at": s.updated_at,
+        "mode": s.mode,
+        "clis": {name: _backend_to_dict(bs) for name, bs in s.clis.items()},
+    }
+
+
+def _backend_to_dict(b: BackendState) -> dict:
+    return {
+        "role_models": dict(b.role_models),
+        "installed": {
+            component: {name: asdict(item) for name, item in items.items()}
+            for component, items in b.installed.items()
+        },
+    }
+
+
+def _state_from_dict(data: dict) -> State:
+    """Load State from JSON dict, handling missing fields defensively."""
+    global_data = data.get("global")
+    global_install = _scope_from_dict(global_data) if global_data else None
+    
+    local_data = data.get("local", {})
+    local_installs = {path: _scope_from_dict(scope_data) for path, scope_data in local_data.items()}
+    
+    memory_data = data.get("memory", {})
+    memory = MemoryConfig(
+        backend=memory_data.get("backend", "local"),
+        path=memory_data.get("path", ""),
+    )
+
+    return State(
+        source_path=data.get("source_path", ""),
+        source_commit=data.get("source_commit", ""),
+        global_install=global_install,
+        local_installs=local_installs,
+        memory=memory,
+    )
+
+
+def _scope_from_dict(data: dict) -> ScopeState:
+    """Load ScopeState from JSON dict."""
+    clis_data = data.get("clis", {})
+    clis = {name: _backend_from_dict(backend_data) for name, backend_data in clis_data.items()}
+    
+    return ScopeState(
+        installed_at=data.get("installed_at", ""),
+        updated_at=data.get("updated_at", ""),
+        mode=data.get("mode", "symlink"),
+        clis=clis,
+    )
+
+
+def _backend_from_dict(data: dict) -> BackendState:
+    """Load BackendState from JSON dict."""
+    role_models = data.get("role_models", {})
+    
+    installed_data = data.get("installed", {})
+    installed = {}
+    for component, items_data in installed_data.items():
+        items = {name: InstalledItem(**item_data) for name, item_data in items_data.items()}
+        installed[component] = items
+    
+    return BackendState(
+        role_models=role_models,
+        installed=installed,
+    )
+
+
+# I/O functions moved from install_state.py
+def record_install_state(state: State) -> None:
+    """Persist state via save_state()."""
+    save_state(state)
+
+
+def load_current_state() -> Optional[State]:
+    return load_state()
+
+
+def remove_install_state(scope: str, project_path: Optional[Path] = None) -> None:
+    """Remove install state for the given scope without affecting other scopes.
+    
+    For uninstall operations - this should only remove the target scope,
+    not clear the entire state file.
+    """
+    current_state = load_state()
+    if current_state is None:
+        return  # Nothing to remove
+    
+    remove_scope(current_state, scope, project_path)
+    
+    # If state is now completely empty, clear the file
+    if current_state.global_install is None and not current_state.local_installs:
+        clear_state()
+    else:
+        save_state(current_state)

agent_notes/services/ui.py

@@ -0,0 +1,419 @@
+"""Terminal UI primitives."""
+
+import sys
+import shutil
+from pathlib import Path
+from typing import List, Tuple, Set
+
+try:
+    import tty
+    import termios
+    _HAS_TTY = True
+except ImportError:
+    _HAS_TTY = False
+
+# Export for backward compatibility
+__all__ = ['Color', 'ok', 'warn', 'fail', 'error', 'info', 'issue', 'linked', 'removed', 'skipped',
+           '_safe_input', '_can_interactive', '_read_key', '_checkbox_select', '_radio_select',
+           '_checkbox_select_fallback', '_radio_select_fallback', '_HAS_TTY',
+           '_clear_screen', '_render_step_header', '_render_nav_footer', '_terminal_width']
+
+
+# --- Colors ---
+class Color:
+    RED = "\033[0;31m"
+    GREEN = "\033[0;32m"
+    YELLOW = "\033[0;33m"
+    BLUE = "\033[0;34m"
+    MAGENTA = "\033[0;35m"
+    CYAN = "\033[0;36m"
+    WHITE = "\033[0;37m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    NC = "\033[0m"  # No color
+
+    @staticmethod
+    def disable():
+        """Disable colors (for non-TTY output)."""
+        for attr in ("RED", "GREEN", "YELLOW", "BLUE", "MAGENTA", "CYAN", "WHITE", "BOLD", "DIM", "NC"):
+            setattr(Color, attr, "")
+
+
+# Disable colors if not a TTY
+if not sys.stdout.isatty():
+    Color.disable()
+
+
+# --- Output helpers ---
+def ok(msg: str, indent: int = 2) -> None:
+    print(f"{' ' * indent}{Color.GREEN}OK{Color.NC}   {msg}")
+
+
+def warn(msg: str, indent: int = 2) -> None:
+    print(f"{' ' * indent}{Color.YELLOW}WARN{Color.NC} {msg}")
+
+
+def fail(msg: str, indent: int = 2) -> None:
+    print(f"{' ' * indent}{Color.RED}FAIL{Color.NC} {msg}")
+
+
+def error(msg: str) -> None:
+    print(f"{Color.RED}Error: {msg}{Color.NC}", file=sys.stderr)
+    sys.exit(1)
+
+
+def info(msg: str) -> None:
+    print(f"  {Color.GREEN}✓{Color.NC} {msg}")
+
+
+def issue(msg: str) -> None:
+    print(f"  {Color.RED}✗{Color.NC} {msg}")
+
+
+def linked(path: str) -> None:
+    print(f"  {Color.GREEN}LINKED{Color.NC}  {path}")
+
+
+def removed(path: str) -> None:
+    print(f"  {Color.GREEN}REMOVED{Color.NC}  {path}")
+
+
+def skipped(path: str, reason: str = "not a symlink — remove manually") -> None:
+    print(f"  {Color.YELLOW}SKIP{Color.NC}     {path} ({reason})")
+
+
+def _terminal_width() -> int:
+    return shutil.get_terminal_size((80, 24)).columns
+
+
+def _clear_screen() -> None:
+    """Clear terminal. No-op when stdout is not a TTY (CI, pipes, tests)."""
+    if sys.stdout.isatty():
+        sys.stdout.write('\033[2J\033[H')
+        sys.stdout.flush()
+
+
+def _render_step_header(step: int, total: int, version: str = '') -> None:
+    """Print the wizard top bar: app name on left, step counter on right."""
+    width = _terminal_width()
+    left_plain = f"  AgentNotes{f' v{version}' if version else ''}"
+    right_plain = f"Step {step} of {total}  "
+    padding = max(1, width - len(left_plain) - len(right_plain))
+    left_col = f"  {Color.BOLD}AgentNotes{Color.NC}{f' {Color.CYAN}v{version}{Color.NC}' if version else ''}"
+    right_col = f"{Color.DIM}Step {step} of {total}{Color.NC}  "
+    sys.stdout.write(f"{left_col}{' ' * padding}{right_col}\n")
+    sys.stdout.write(f"{Color.DIM}{'─' * width}{Color.NC}\n\n")
+    sys.stdout.flush()
+
+
+def _render_nav_footer(mode: str = 'checkbox') -> None:
+    """Print the bottom separator + key hint line."""
+    width = _terminal_width()
+    sys.stdout.write(f"\n{Color.DIM}{'─' * width}{Color.NC}\n")
+    if mode == 'checkbox':
+        hints = (f"  {Color.DIM}↑↓{Color.NC} navigate"
+                 f"   {Color.DIM}space{Color.NC} toggle"
+                 f"   {Color.DIM}enter{Color.NC} confirm"
+                 f"   {Color.DIM}q{Color.NC} quit")
+    else:
+        hints = (f"  {Color.DIM}↑↓{Color.NC} navigate"
+                 f"   {Color.DIM}enter{Color.NC} confirm"
+                 f"   {Color.DIM}q{Color.NC} quit")
+    sys.stdout.write(hints + "\n")
+    sys.stdout.flush()
+
+
+# --- TUI primitives ---
+def _safe_input(prompt: str, default: str = "") -> str:
+    """Safe input that handles EOF and interrupts."""
+    try:
+        result = input(prompt).strip()
+        return result if result else default
+    except (KeyboardInterrupt, EOFError):
+        print("\nInstallation cancelled.")
+        sys.exit(0)
+
+
+def _can_interactive() -> bool:
+    """Check if interactive TUI is available."""
+    return _HAS_TTY and sys.stdin.isatty()
+
+
+def _read_key():
+    """Read a single keypress."""
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        ch = sys.stdin.read(1)
+        if ch == '\x1b':  # Escape sequence
+            ch2 = sys.stdin.read(1)
+            ch3 = sys.stdin.read(1)
+            if ch2 == '[':
+                if ch3 == 'A': return 'up'
+                if ch3 == 'B': return 'down'
+            return 'escape'
+        if ch == ' ': return 'space'
+        if ch in ('\r', '\n'): return 'enter'
+        if ch == '\x03': raise KeyboardInterrupt
+        return ch
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+def _checkbox_select(title: str, options: List[Tuple[str, str]], defaults: Set[str] = None,
+                     step: int = 0, total: int = 0, version: str = '') -> Set[str]:
+    """Interactive checkbox selector.
+
+    Args:
+        title: Header text
+        options: List of (label, value) tuples
+        defaults: Set of values that are pre-selected
+        step: Wizard step number (0 = legacy in-place mode)
+        total: Total wizard steps
+        version: App version string
+
+    Returns:
+        Set of selected values
+    """
+    if defaults is None:
+        defaults = {v for _, v in options}
+
+    selected = set(defaults)
+    cursor = 0
+
+    if not _can_interactive():
+        return selected
+
+    if step > 0:
+        def render():
+            _clear_screen()
+            _render_step_header(step, total, version)
+            sys.stdout.write(f"  {title}\n\n")
+            for i, (label, value) in enumerate(options):
+                check = "✓" if value in selected else " "
+                pointer = "›" if i == cursor else " "
+                sys.stdout.write(f"  {pointer} [{check}] {label}\n")
+            _render_nav_footer('checkbox')
+            sys.stdout.flush()
+
+        render()
+
+        while True:
+            key = _read_key()
+
+            if key == 'up':
+                cursor = (cursor - 1) % len(options)
+            elif key == 'down':
+                cursor = (cursor + 1) % len(options)
+            elif key == 'space':
+                value = options[cursor][1]
+                if value in selected:
+                    selected.discard(value)
+                else:
+                    selected.add(value)
+            elif key == 'enter':
+                return selected
+            elif key == 'escape':
+                return selected
+            elif key in ('q', 'Q'):
+                print("\nInstallation cancelled.")
+                sys.exit(0)
+
+            render()
+    else:
+        # Legacy in-place mode
+        prev_lines = 0
+
+        def render():
+            nonlocal prev_lines
+            if prev_lines:
+                sys.stdout.write(f"\033[{prev_lines}A")
+            lines = []
+            header = f"{title} (↑↓ navigate, space toggle, enter confirm)"
+            lines.extend(header.split("\n"))
+            lines.append("")  # blank separator
+            for i, (label, value) in enumerate(options):
+                check = "✓" if value in selected else " "
+                pointer = "›" if i == cursor else " "
+                lines.append(f"  {pointer} [{check}] {label}")
+            lines.append("")  # trailing blank
+            for line in lines:
+                sys.stdout.write(f"\r\033[K{line}\n")
+            sys.stdout.flush()
+            prev_lines = len(lines)
+
+        render()
+
+        while True:
+            key = _read_key()
+
+            if key == 'up':
+                cursor = (cursor - 1) % len(options)
+            elif key == 'down':
+                cursor = (cursor + 1) % len(options)
+            elif key == 'space':
+                value = options[cursor][1]
+                if value in selected:
+                    selected.discard(value)
+                else:
+                    selected.add(value)
+            elif key == 'enter':
+                return selected
+            elif key == 'escape':
+                return selected
+            elif key in ('q', 'Q'):
+                print("\nInstallation cancelled.")
+                sys.exit(0)
+
+            render()
+
+    return selected
+
+
+def _radio_select(title: str, options: List[Tuple[str, str]], default: int = 0,
+                  step: int = 0, total: int = 0, version: str = ''):
+    """Interactive single-choice selector.
+
+    Args:
+        title: Header text (may contain \\n for multi-line titles)
+        options: List of (label, value) tuples
+        default: Index of default selection
+        step: Wizard step number (0 = legacy in-place mode)
+        total: Total wizard steps
+        version: App version string
+
+    Returns:
+        Selected value
+    """
+    cursor = default
+
+    if not _can_interactive():
+        return options[default][1]
+
+    if step > 0:
+        def render():
+            _clear_screen()
+            _render_step_header(step, total, version)
+            sys.stdout.write(f"  {title}\n\n")
+            for i, (label, value) in enumerate(options):
+                dot = "●" if i == cursor else "○"
+                pointer = "›" if i == cursor else " "
+                sys.stdout.write(f"  {pointer} {dot} {label}\n")
+            _render_nav_footer('radio')
+            sys.stdout.flush()
+
+        render()
+
+        while True:
+            key = _read_key()
+
+            if key == 'up':
+                cursor = (cursor - 1) % len(options)
+            elif key == 'down':
+                cursor = (cursor + 1) % len(options)
+            elif key == 'enter':
+                return options[cursor][1]
+            elif key == 'escape':
+                return options[cursor][1]
+            elif key in ('q', 'Q'):
+                print("\nInstallation cancelled.")
+                sys.exit(0)
+
+            render()
+    else:
+        # Legacy in-place mode
+        prev_lines = 0
+
+        def render():
+            nonlocal prev_lines
+            if prev_lines:
+                sys.stdout.write(f"\033[{prev_lines}A")
+            lines = []
+            header = f"{title} (↑↓ navigate, enter confirm)"
+            lines.extend(header.split("\n"))
+            lines.append("")
+            for i, (label, value) in enumerate(options):
+                dot = "●" if i == cursor else "○"
+                pointer = "›" if i == cursor else " "
+                lines.append(f"  {pointer} {dot} {label}")
+            lines.append("")
+            for line in lines:
+                sys.stdout.write(f"\r\033[K{line}\n")
+            sys.stdout.flush()
+            prev_lines = len(lines)
+
+        render()
+
+        while True:
+            key = _read_key()
+
+            if key == 'up':
+                cursor = (cursor - 1) % len(options)
+            elif key == 'down':
+                cursor = (cursor + 1) % len(options)
+            elif key == 'enter':
+                return options[cursor][1]
+            elif key == 'escape':
+                return options[cursor][1]
+            elif key in ('q', 'Q'):
+                print("\nInstallation cancelled.")
+                sys.exit(0)
+
+            render()
+
+
+def _checkbox_select_fallback(title: str, options: List[Tuple[str, str]], defaults: Set[str] = None,
+                              step: int = 0, total: int = 0, version: str = '') -> Set[str]:
+    """Fallback checkbox using numbered input."""
+    if defaults is None:
+        defaults = {v for _, v in options}
+
+    if step > 0:
+        print(f"\n  {Color.BOLD}AgentNotes{Color.NC}{f' {Color.CYAN}v{version}{Color.NC}' if version else ''}  —  Step {step} of {total}\n")
+
+    print(f"{title}\n")
+    for i, (label, value) in enumerate(options, 1):
+        marker = "*" if value in defaults else " "
+        print(f"  {i}) [{marker}] {label}")
+    print(f"\n  Enter numbers to toggle (comma-separated), or press enter for defaults.")
+
+    choice = _safe_input("Choice: ", "").strip()
+    if not choice:
+        return set(defaults)
+
+    selected = set(defaults)
+    for part in choice.split(","):
+        try:
+            idx = int(part.strip()) - 1
+            if 0 <= idx < len(options):
+                value = options[idx][1]
+                if value in selected:
+                    selected.discard(value)
+                else:
+                    selected.add(value)
+        except ValueError:
+            continue
+    return selected
+
+
+def _radio_select_fallback(title: str, options: List[Tuple[str, str]], default: int = 0,
+                           step: int = 0, total: int = 0, version: str = ''):
+    """Fallback radio using numbered input."""
+    if step > 0:
+        print(f"\n  {Color.BOLD}AgentNotes{Color.NC}{f' {Color.CYAN}v{version}{Color.NC}' if version else ''}  —  Step {step} of {total}\n")
+
+    print(f"{title}\n")
+    for i, (label, value) in enumerate(options, 1):
+        marker = "*" if i - 1 == default else " "
+        print(f"  {i}) {marker} {label}")
+    print("")
+
+    choice = _safe_input(f"Choice [{default + 1}]: ", str(default + 1))
+    try:
+        idx = int(choice) - 1
+        if 0 <= idx < len(options):
+            return options[idx][1]
+    except ValueError:
+        pass
+    return options[default][1]