scry-run 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

scry_run/__init__.py

@@ -72,7 +72,7 @@ def is_generated(obj: Any) -> bool:
     return getattr(obj, marker, False)
 
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 __all__ = [
     "ScryClass",
     "ScryMeta",

scry_run/cli/__init__.py

@@ -13,6 +13,7 @@ from scry_run.cli.run import run
 from scry_run.cli.env import env
 from scry_run.cli.apps import list_apps, which_app, rm_app, reset_app, info_app
 from scry_run.cli.config_cmd import config_cmd
+from scry_run.cli.log import log_cmd
 from scry_run.generator import CodeGenerator, ScryRunError
 
 
@@ -131,6 +132,7 @@ main.add_command(rm_app, name="rm")
 main.add_command(reset_app, name="reset")
 main.add_command(info_app, name="info")
 main.add_command(config_cmd, name="config")
+main.add_command(log_cmd, name="log")
 
 
 if __name__ == "__main__":

scry_run/cli/init.py

@@ -39,7 +39,7 @@ IMPORTANT GUIDELINES:
 - STICK TO WHAT THE USER ASKED FOR - don't add unrelated features
 - Less is more - a focused app is better than a bloated one
 - If the user said "todo list", make a todo list - not a project management suite
-- Total length: 100-200 words (keep it concise!)
+- Total description length: 100-200 words (keep it concise!)
 
 **OPEN WORLD PRINCIPLE**: This app uses scry-run for dynamic code generation. Methods are generated on-demand at runtime, meaning the set of commands is effectively unlimited - but inputs must still be STRUCTURED like a normal CLI:
 - Use standard CLI patterns: commands, subcommands, flags, and positional arguments
@@ -52,10 +52,23 @@ IMPORTANT GUIDELINES:
   - GOOD: `todo add "buy milk"`, `todo list --due=today`, `todo done 3`
   - BAD: `todo what's due today?` (question form)
 
-Return ONLY the expanded description text, no JSON or markdown code blocks.'''
+**APP FLAGS** - Recommend runtime flags for the app:
+- "quiet": true - For TUI/interactive apps (curses, textual, rich.live, pygame, etc.)
+  This shows scry-run status in terminal title bar instead of stderr, preventing display disruption.
+  Only set to true if the app uses a TUI or graphical library.
 
+Return a JSON object with this structure:
+{{
+  "description": "The expanded description text here...",
+  "flags": {{
+    "quiet": false
+  }}
+}}
 
-def expand_description(name: str, description: str) -> str | None:
+Return ONLY the JSON object, no markdown code fences or explanation.'''
+
+
+def expand_description(name: str, description: str) -> dict | None:
     """Use LLM to expand a brief description into a detailed one.
 
     Args:
@@ -63,7 +76,7 @@ def expand_description(name: str, description: str) -> str | None:
         description: User's brief description
 
     Returns:
-        Expanded description, or None if expansion fails
+        Dict with 'description' and 'flags' keys, or None if expansion fails
     """
     try:
         from scry_run.generator import CodeGenerator, ScryRunError
@@ -72,8 +85,32 @@ def expand_description(name: str, description: str) -> str | None:
         prompt = EXPAND_PROMPT.format(name=name, description=description)
 
         # Use generate_freeform for text generation
-        expanded = generator.generate_freeform(prompt)
-        return expanded.strip()
+        response = generator.generate_freeform(prompt)
+        response = response.strip()
+
+        # Parse JSON response
+        # Handle potential markdown code fences
+        if response.startswith("```"):
+            lines = response.split("\n")
+            # Remove first and last lines (code fences)
+            response = "\n".join(lines[1:-1])
+
+        result = json.loads(response)
+
+        # Validate structure
+        if "description" not in result:
+            console.print("[yellow]Warning:[/yellow] LLM response missing 'description' field")
+            return None
+
+        # Ensure flags exists with defaults
+        if "flags" not in result:
+            result["flags"] = {}
+
+        return result
+
+    except json.JSONDecodeError as e:
+        console.print(f"[yellow]Warning:[/yellow] Could not parse LLM response as JSON: {e}")
+        return None
     except ScryRunError as e:
         console.print(f"[yellow]Warning:[/yellow] Could not expand description: {e.message}")
         return None
@@ -241,10 +278,17 @@ def to_class_name(name: str) -> str:
     default=True,
     help="Automatically expand description with features and examples (default: enabled)",
 )
+@click.option(
+    "--yes", "-y",
+    is_flag=True,
+    default=False,
+    help="Auto-approve all prompts (expanded description, overwrite existing app)",
+)
 def init(
     name: str | None,
     description: str | None,
     auto_expand: bool,
+    yes: bool,
 ) -> None:
     """Initialize a new scry-run app.
 
@@ -279,41 +323,57 @@ def init(
         )
 
     # Auto-expand description using LLM
+    # Track recommended flags from LLM
+    recommended_flags: dict = {}
+
     if auto_expand:
         console.print()
         console.print("[dim]Expanding description with AI...[/dim]")
-        expanded = expand_description(name, description)
+        result = expand_description(name, description)
+
+        if result:
+            expanded_desc = result["description"]
+            recommended_flags = result.get("flags", {})
 
-        if expanded:
             # Show the expanded description
             console.print()
             panel = Panel(
-                expanded,
+                expanded_desc,
                 title="[bold]Expanded Description[/bold]",
                 border_style="blue",
             )
             console.print(panel)
+
+            # Show recommended flags if any are non-default
+            if recommended_flags.get("quiet"):
+                console.print("[dim]Recommended: quiet mode (TUI app)[/dim]")
+
             console.print()
 
-            # Let user confirm, edit, or reject
-            console.print("[dim](y)es, (n)o, or (e)dit in $EDITOR[/dim]")
-            choice = Prompt.ask(
-                "Use this description?",
-                choices=["y", "n", "e"],
-                default="y",
-            )
-            if choice == "y":
-                description = expanded
-            elif choice == "e":
-                # Open in editor
-                edited = click.edit(expanded)
-                if edited:
-                    description = edited.strip()
-                    console.print("[dim]Using edited description.[/dim]")
-                else:
-                    console.print("[dim]Editor returned empty, using original.[/dim]")
+            # Auto-approve or let user confirm
+            if yes:
+                description = expanded_desc
             else:
-                console.print("[dim]Using original description.[/dim]")
+                # Let user confirm, edit, or reject
+                console.print("[dim](y)es, (n)o, or (e)dit in $EDITOR[/dim]")
+                choice = Prompt.ask(
+                    "Use this description?",
+                    choices=["y", "n", "e"],
+                    default="y",
+                )
+                if choice == "y":
+                    description = expanded_desc
+                elif choice == "e":
+                    # Open in editor
+                    edited = click.edit(expanded_desc)
+                    if edited:
+                        description = edited.strip()
+                        console.print("[dim]Using edited description.[/dim]")
+                    else:
+                        console.print("[dim]Editor returned empty, using original.[/dim]")
+                else:
+                    console.print("[dim]Using original description.[/dim]")
+                    recommended_flags = {}  # Reset flags if user rejected expansion
         else:
             console.print("[dim]Using original description.[/dim]")
 
@@ -330,7 +390,7 @@ def init(
 
     # Check for existing app
     if app_dir.exists():
-        if not Confirm.ask(f"[yellow]App '{name}' already exists[/yellow]. Overwrite?"):
+        if not yes and not Confirm.ask(f"[yellow]App '{name}' already exists[/yellow]. Overwrite?"):
             console.print("[yellow]Aborted.[/yellow]")
             raise SystemExit(0)
 
@@ -356,6 +416,15 @@ def init(
     cache_file = app_dir / "cache.json"
     cache_file.write_text(json.dumps({}))
 
+    # Create settings.json with default flags from LLM recommendation
+    settings = {
+        "default_flags": {
+            "quiet": recommended_flags.get("quiet", False),
+        }
+    }
+    settings_file = app_dir / "settings.json"
+    settings_file.write_text(json.dumps(settings, indent=2))
+
     # Create logs directory
     logs_dir = app_dir / "logs"
     logs_dir.mkdir(exist_ok=True)
@@ -365,7 +434,11 @@ def init(
     console.print()
     console.print(f"  [dim]Location:[/dim]  {app_dir}")
     console.print(f"  [dim]Main file:[/dim] {app_file}")
+    console.print(f"  [dim]Settings:[/dim]  {settings_file}")
     console.print()
+    if recommended_flags.get("quiet"):
+        console.print("[dim]Quiet mode enabled (TUI app) - status shown in title bar.[/dim]")
+        console.print()
     console.print("[bold]Useful commands:[/bold]")
     console.print(f"  [cyan]scry-run run {name}[/cyan]         Run your app")
     console.print(f"  [cyan]scry-run info {name}[/cyan]        View app details and cache stats")

scry_run/cli/log.py

@@ -0,0 +1,373 @@
+"""Log command for scry-run.
+
+Watches an app's log directory and tails log files as they update.
+"""
+
+import datetime
+import re
+import sys
+import time
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.text import Text
+
+from scry_run.home import get_app_dir, get_app_logs
+
+console = Console()
+
+_COLOR_PALETTE = [
+    "cyan",
+    "magenta",
+    "green",
+    "yellow",
+    "blue",
+    "bright_cyan",
+    "bright_magenta",
+    "bright_green",
+    "bright_yellow",
+    "bright_blue",
+]
+
+_LEVEL_COLORS = {
+    "DEBUG": "dim",
+    "INFO": "green",
+    "WARN": "yellow",
+    "WARNING": "yellow",
+    "ERROR": "red",
+}
+
+_LOG_HEADER_RE = re.compile(r"^\[(?P<ts>[^\]]+)\]\s+\[(?P<level>[A-Z]+)\]\s+")
+
+
+_DURATION_RE = re.compile(r"^\d+(?:\.\d+)?[smh]?$")
+
+
+def _parse_duration(value: str) -> float:
+    """Parse a duration like '30s', '10m', '1h' into seconds."""
+    s = value.strip().lower()
+    if not s:
+        raise ValueError("duration cannot be empty")
+
+    unit = s[-1]
+    if unit.isdigit():
+        # seconds by default
+        return float(s)
+
+    number = s[:-1]
+    if not number:
+        raise ValueError(f"invalid duration: {value}")
+
+    try:
+        qty = float(number)
+    except ValueError as exc:
+        raise ValueError(f"invalid duration: {value}") from exc
+
+    if unit == "s":
+        return qty
+    if unit == "m":
+        return qty * 60.0
+    if unit == "h":
+        return qty * 3600.0
+
+    raise ValueError(f"invalid duration unit: {value}")
+
+
+def _normalize_dt(value: datetime.datetime) -> datetime.datetime:
+    if value.tzinfo is None:
+        return value
+    return value.astimezone().replace(tzinfo=None)
+
+
+def _parse_since(value: str, now: datetime.datetime) -> datetime.datetime:
+    s = value.strip()
+    if not s:
+        raise ValueError("since cannot be empty")
+
+    if _DURATION_RE.match(s.lower()):
+        seconds = _parse_duration(s)
+        return now - datetime.timedelta(seconds=seconds)
+
+    try:
+        parsed = datetime.datetime.fromisoformat(s)
+    except ValueError as exc:
+        raise ValueError(f"invalid since value: {value}") from exc
+
+    return _normalize_dt(parsed)
+
+
+def _parse_log_timestamp(line: str) -> datetime.datetime | None:
+    raw = line.lstrip()
+    if not raw.startswith("["):
+        return None
+    end = raw.find("]")
+    if end == -1:
+        return None
+    ts_str = raw[1:end]
+    try:
+        return _normalize_dt(datetime.datetime.fromisoformat(ts_str))
+    except ValueError:
+        return None
+
+
+@dataclass
+class _TailState:
+    path: Path
+    position: int
+    buffer: str
+
+
+class _OutputLock:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+
+    def write(self, data: Text | str) -> None:
+        with self._lock:
+            if isinstance(data, Text):
+                console.print(data, end="")
+            else:
+                sys.stdout.write(data)
+                sys.stdout.flush()
+
+
+def _iter_recent_logs(log_dir: Path, since_seconds: float) -> list[Path]:
+    now = time.time()
+    paths: list[Path] = []
+    for path in sorted(log_dir.glob("*.log")):
+        try:
+            if (now - path.stat().st_mtime) <= since_seconds:
+                paths.append(path)
+        except FileNotFoundError:
+            continue
+    return paths
+
+
+def _read_new_data(state: _TailState) -> list[str]:
+    try:
+        size = state.path.stat().st_size
+    except FileNotFoundError:
+        return []
+
+    if size < state.position:
+        # File truncated or rotated; start over
+        state.position = 0
+        state.buffer = ""
+
+    try:
+        with state.path.open("r", encoding="utf-8", errors="replace") as f:
+            f.seek(state.position)
+            data = f.read()
+            state.position = f.tell()
+    except FileNotFoundError:
+        return []
+
+    if not data:
+        return []
+
+    chunk = state.buffer + data
+    lines = chunk.splitlines(keepends=True)
+    output: list[str] = []
+    state.buffer = ""
+    for line in lines:
+        if line.endswith("\n") or line.endswith("\r"):
+            output.append(line)
+        else:
+            state.buffer = line
+    return output
+
+
+def _color_for_name(name: str) -> str:
+    return _COLOR_PALETTE[hash(name) % len(_COLOR_PALETTE)]
+
+
+def _build_colored_lines(path: Path, lines: list[str], short_mode: bool = False) -> Text:
+    text = Text()
+    prefix = "> " if short_mode else f"[{path.name}] "
+    prefix_style = "dim" if short_mode else _color_for_name(path.name)
+
+    for line in lines:
+        text.append(prefix, style=prefix_style)
+
+        stripped = line.strip()
+        if stripped and all(ch == "=" for ch in stripped):
+            text.append(line, style="dim")
+            continue
+        if stripped and all(ch == "-" for ch in stripped):
+            text.append(line, style="dim")
+            continue
+
+        match = _LOG_HEADER_RE.match(line)
+        if match:
+            ts = match.group("ts")
+            level = match.group("level")
+            level_style = _LEVEL_COLORS.get(level, "white")
+            header_len = match.end()
+            rest = line[header_len:]
+            if not short_mode:
+                text.append(f"[{ts}] ", style="dim")
+            text.append(f"[{level}] ", style=level_style)
+            text.append(rest)
+            continue
+
+        text.append(line)
+
+    return text
+
+
+def _find_offset_for_since(path: Path, cutoff: datetime.datetime) -> int:
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as f:
+            prev_pos = 0
+            prev_line_sep = False
+            while True:
+                pos = f.tell()
+                line = f.readline()
+                if not line:
+                    return f.tell()
+
+                ts = _parse_log_timestamp(line)
+                if ts and ts >= cutoff:
+                    return prev_pos if prev_line_sep else pos
+
+                prev_line_sep = line.strip() == "=" * 80
+                prev_pos = pos
+    except FileNotFoundError:
+        return 0
+
+
+def _wait_for_log_dir(
+    app_name: str,
+    *,
+    poll_interval: float = 0.2,
+    max_wait_seconds: float | None = None,
+) -> Path:
+    """Wait for an app's logs directory to be created.
+
+    By default this waits indefinitely. ``max_wait_seconds`` is only intended
+    for tests to avoid hanging.
+    """
+    app_dir = get_app_dir(app_name)
+    log_dir = get_app_logs(app_name)
+
+    warned = False
+    started = time.monotonic()
+
+    while True:
+        if log_dir.exists() and log_dir.is_dir():
+            if warned:
+                console.print(f"[dim]Found logs directory: {log_dir}[/dim]")
+            return log_dir
+
+        if not warned:
+            if not app_dir.exists():
+                console.print(f"[yellow]Warning:[/yellow] App '{app_name}' not found yet.")
+                console.print(f"[dim]Waiting for logs directory: {log_dir}[/dim]")
+            else:
+                console.print(f"[yellow]Warning:[/yellow] Logs directory for app '{app_name}' not found yet.")
+                console.print(f"[dim]Waiting for logs directory: {log_dir}[/dim]")
+            warned = True
+
+        if max_wait_seconds is not None and (time.monotonic() - started) >= max_wait_seconds:
+            raise TimeoutError(f"Timed out waiting for logs directory: {log_dir}")
+
+        time.sleep(poll_interval)
+
+
+@click.command("log")
+@click.argument("app_name")
+@click.option(
+    "--since",
+    default="1m",
+    show_default=True,
+    help="Start from entries since this time (e.g., 30m, 1h, 10s, or 2026-02-04T12:30:00).",
+)
+@click.option(
+    "--debounce",
+    default=0.2,
+    show_default=True,
+    type=float,
+    help="Debounce time in seconds for filesystem events.",
+)
+@click.option(
+    "--short",
+    "short_mode",
+    is_flag=True,
+    help="Use compact output prefix ('> ') instead of log filename.",
+)
+def log_cmd(app_name: str, since: str, debounce: float, short_mode: bool) -> None:
+    """Watch an app's log directory and tail log files."""
+    try:
+        from watchfiles import Change, watch
+    except ModuleNotFoundError:
+        console.print("[red]Error:[/red] Missing dependency: watchfiles")
+        console.print("[dim]Install/update scry-run to include watchfiles, then retry.[/dim]")
+        sys.exit(1)
+
+    try:
+        log_dir = _wait_for_log_dir(app_name)
+    except KeyboardInterrupt:
+        console.print("\n[dim]Stopped waiting for logs.[/dim]")
+        return
+
+    now = datetime.datetime.now()
+    try:
+        since_cutoff = _parse_since(since, now)
+    except ValueError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        sys.exit(1)
+
+    if debounce < 0:
+        console.print("[red]Error:[/red] debounce must be >= 0")
+        sys.exit(1)
+
+    debounce_ms = int(debounce * 1000)
+
+    console.print(f"[cyan]Watching logs in:[/cyan] {log_dir}")
+    console.print(f"[dim]Since:[/dim] {since}  [dim]Press Ctrl+C to stop[/dim]")
+
+    states: dict[Path, _TailState] = {}
+    output_lock = _OutputLock()
+
+    # Seed with recent log files based on mtime, then seek to cutoff by entry timestamp
+    for path in _iter_recent_logs(log_dir, (now - since_cutoff).total_seconds()):
+        offset = _find_offset_for_since(path, since_cutoff)
+        states[path] = _TailState(path=path, position=offset, buffer="")
+
+    # Print existing entries since cutoff on startup
+    for path, state in states.items():
+        lines = _read_new_data(state)
+        if not lines:
+            continue
+        output_lock.write(_build_colored_lines(path, lines, short_mode=short_mode))
+
+    try:
+        for changes in watch(log_dir, debounce=debounce_ms):
+            paths_to_read: set[Path] = set()
+
+            for change, raw_path in changes:
+                path = Path(raw_path)
+                if path.suffix != ".log":
+                    continue
+
+                if change == Change.deleted:
+                    states.pop(path, None)
+                    continue
+
+                if path not in states:
+                    offset = _find_offset_for_since(path, since_cutoff)
+                    states[path] = _TailState(path=path, position=offset, buffer="")
+                paths_to_read.add(path)
+
+            for path in paths_to_read:
+                state = states.get(path)
+                if not state:
+                    continue
+                lines = _read_new_data(state)
+                if not lines:
+                    continue
+                output_lock.write(_build_colored_lines(path, lines, short_mode=short_mode))
+    except KeyboardInterrupt:
+        console.print("\n[dim]Stopped watching logs.[/dim]")

scry_run/cli/run.py

@@ -1,5 +1,6 @@
 """Run command for executing scry-run apps."""
 
+import json
 import os
 import subprocess
 
@@ -9,15 +10,28 @@ from rich.console import Console
 from scry_run.home import get_app_dir
 from scry_run.config import load_config, get_env_vars
 from scry_run.packages import ensure_scry_run_installed
+from scry_run.logging import get_logger
 
 console = Console()
 
 
+def load_app_settings(app_dir) -> dict:
+    """Load per-app settings from settings.json."""
+    settings_file = app_dir / "settings.json"
+    if settings_file.exists():
+        try:
+            return json.loads(settings_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
 @click.command(context_settings={"ignore_unknown_options": True, "allow_extra_args": True})
+@click.option("--quiet", "-q", is_flag=True, help="Suppress status messages (for TUI apps)")
 @click.argument("app_name")
 @click.argument("args", nargs=-1, type=click.UNPROCESSED)
 @click.pass_context
-def run(ctx, app_name: str, args: tuple[str, ...]) -> None:
+def run(ctx, quiet: bool, app_name: str, args: tuple[str, ...]) -> None:
     """Run an scry-run app.
 
     Loads config from ~/.scry-run/config.toml, converts to env vars,
@@ -28,6 +42,7 @@ def run(ctx, app_name: str, args: tuple[str, ...]) -> None:
         scry-run run todo-app
         scry-run run todo-app add "Buy milk"
         scry-run run todo-app --help
+        scry-run run --quiet my-tui-app
     """
     # Find app
     app_dir = get_app_dir(app_name)
@@ -41,6 +56,10 @@ def run(ctx, app_name: str, args: tuple[str, ...]) -> None:
         console.print(f"  [cyan]scry-run init --name {app_name} --description '...'[/cyan]")
         ctx.exit(1)
 
+    # Load per-app settings
+    app_settings = load_app_settings(app_dir)
+    default_flags = app_settings.get("default_flags", {})
+
     # Load config and convert to env vars
     config = load_config()
     env_vars = get_env_vars(config)
@@ -49,6 +68,12 @@ def run(ctx, app_name: str, args: tuple[str, ...]) -> None:
     env = os.environ.copy()
     env.update(env_vars)
 
+    # Set quiet mode if requested via flag OR app default
+    # CLI flag takes precedence over app settings
+    use_quiet = quiet or default_flags.get("quiet", False)
+    if use_quiet:
+        env["SCRY_QUIET"] = "1"
+
     # Clear venv-related environment variables to prevent interference
     # from an activated venv (uv run --directory will use the app's venv)
     env.pop("VIRTUAL_ENV", None)
@@ -63,9 +88,20 @@ def run(ctx, app_name: str, args: tuple[str, ...]) -> None:
     # Ensure app has scry-run installed
     ensure_scry_run_installed(app_dir)
 
+    logger = get_logger()
+    logger.set_app_context(app_dir)
+    logger.info(f"App starting: {app_name}")
+
     # Build command
     cmd = ["uv", "run", "--directory", str(app_dir), "python", str(app_py)] + list(args)
 
     # Run app
-    result = subprocess.run(cmd, env=env)
-    ctx.exit(result.returncode)
+    return_code = 0
+    try:
+        result = subprocess.run(cmd, env=env)
+        return_code = result.returncode
+    except KeyboardInterrupt:
+        return_code = 130
+    finally:
+        logger.info(f"App shutting down: {app_name} (exit_code={return_code})")
+    ctx.exit(return_code)

scry_run/config.py

@@ -101,6 +101,8 @@ def load_config() -> Config:
         kwargs["full_context"] = env_full_context.lower() in ("true", "1", "yes")
     if env_log_level := os.environ.get("SCRY_LOG_LEVEL"):
         kwargs["log_level"] = env_log_level
+    if env_model := os.environ.get("SCRY_MODEL"):
+        kwargs["claude_model"] = env_model
 
     return Config(**kwargs)
 
@@ -131,11 +133,7 @@ def get_env_vars(config: Config) -> dict[str, str]:
     set_if_value("SCRY_FULL_CONTEXT", config.full_context)
     set_if_value("SCRY_LOG_LEVEL", config.log_level)
 
-    # Model env vars - export for selected backend, but always preserve existing env vars
-    if config.backend == "claude":
-        set_if_value("SCRY_MODEL", config.claude_model)
-    # For "auto" or other: still preserve any existing env vars
-    if "SCRY_MODEL" in os.environ:
-        env_vars["SCRY_MODEL"] = os.environ["SCRY_MODEL"]
+    # Model env var - export if configured (works for claude and auto backends)
+    set_if_value("SCRY_MODEL", config.claude_model)
 
     return env_vars

scry_run/console.py

@@ -1,5 +1,7 @@
 """Console output utilities for consistent styling."""
 
+import os
+import sys
 from datetime import datetime
 
 from rich.console import Console
@@ -8,23 +10,54 @@ from rich.console import Console
 err_console = Console(stderr=True, highlight=False)
 
 
+def _is_quiet() -> bool:
+    """Check if quiet mode is enabled (SCRY_QUIET=1)."""
+    return os.environ.get("SCRY_QUIET", "").lower() in ("1", "true", "yes", "on")
+
+
+def _set_title(msg: str) -> None:
+    """Set terminal title bar. Used in quiet mode to show progress."""
+    # OSC escape sequence to set window title
+    # \033]0; sets both window title and icon name
+    # \007 is the bell character that terminates the sequence
+    sys.stderr.write(f"\033]0;[scry-run] {msg}\007")
+    sys.stderr.flush()
+
+
+_START_TIME = datetime.now()
+
+
 def _timestamp() -> str:
-    """Return current time as HH:MM:SS."""
-    return datetime.now().strftime("%H:%M:%S")
+    """Return time since app start as HH:MM:SS."""
+    elapsed = datetime.now() - _START_TIME
+    total_seconds = int(elapsed.total_seconds())
+    hours = total_seconds // 3600
+    minutes = (total_seconds % 3600) // 60
+    seconds = total_seconds % 60
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
 
 
 def status(msg: str) -> None:
-    """Print a dim status message."""
+    """Print a dim status message. Uses title bar in quiet mode."""
+    if _is_quiet():
+        _set_title(msg)
+        return
     err_console.print(f"[dim]{_timestamp()} \\[scry-run][/dim] {msg}")
 
 
 def info(msg: str) -> None:
-    """Print an info message (cyan)."""
+    """Print an info message (cyan). Uses title bar in quiet mode."""
+    if _is_quiet():
+        _set_title(msg)
+        return
     err_console.print(f"[dim]{_timestamp()}[/dim] [cyan]\\[scry-run][/cyan] {msg}")
 
 
 def success(msg: str) -> None:
-    """Print a success message (green)."""
+    """Print a success message (green). Uses title bar in quiet mode."""
+    if _is_quiet():
+        _set_title(f"✓ {msg}")
+        return
     err_console.print(f"[dim]{_timestamp()}[/dim] [green]\\[scry-run][/green] {msg}")
 
 
@@ -39,21 +72,33 @@ def error(msg: str) -> None:
 
 
 def generating(class_name: str, attr_name: str) -> None:
-    """Print a 'generating' message."""
+    """Print a 'generating' message. Uses title bar in quiet mode."""
+    if _is_quiet():
+        _set_title(f"Generating {class_name}.{attr_name}...")
+        return
     err_console.print(f"[dim]{_timestamp()}[/dim] [cyan]\\[scry-run][/cyan] Generating {class_name}.{attr_name}...")
 
 
 def generated(class_name: str, attr_name: str) -> None:
-    """Print a 'generated' success message."""
+    """Print a 'generated' success message. Uses title bar in quiet mode."""
+    if _is_quiet():
+        _set_title(f"✓ Generated {class_name}.{attr_name}")
+        return
     err_console.print(f"[dim]{_timestamp()}[/dim] [green]\\[scry-run][/green] Generated {class_name}.{attr_name} ✓")
 
 
 def using_cached(class_name: str, attr_name: str) -> None:
-    """Print a 'using cached' message."""
+    """Print a 'using cached' message. Uses title bar in quiet mode."""
+    if _is_quiet():
+        _set_title(f"Using cached {class_name}.{attr_name}")
+        return
     err_console.print(f"[dim]{_timestamp()} \\[scry-run][/dim] Using cached {class_name}.{attr_name}")
 
 
 def backend_selected(backend_name: str, model: str | None, reason: str) -> None:
-    """Print backend selection message."""
+    """Print backend selection message. Uses title bar in quiet mode."""
+    if _is_quiet():
+        _set_title(f"Backend: {backend_name}")
+        return
     model_str = f" (model={model})" if model else ""
     err_console.print(f"[dim]{_timestamp()} \\[scry-run][/dim] Using backend: {backend_name}{model_str} ({reason})")

scry_run/logging.py

@@ -17,14 +17,14 @@ class ScryRunLogger:
     Log file is created in:
     1. The app's logs/ directory (if running in an app context)
     2. Directory specified by SCRY_LOG_DIR
-    3. Current working directory (fallback)
+    3. ~/.scry-run/logs/ (fallback for CLI commands)
     """
-    
+
     _instance: Optional["ScryRunLogger"] = None
-    
+
     def __init__(self, log_dir: Optional[Path] = None):
         """Initialize logger.
-        
+
         Args:
             log_dir: Directory for log file. If None, uses auto-detection.
         """
@@ -32,24 +32,27 @@ class ScryRunLogger:
         self._log_file: Optional[Path] = None
         # Session timestamp for unique log files per run
         self._session_id = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        
+
         if log_dir:
             self._log_dir = log_dir
         else:
             env_dir = os.environ.get("SCRY_LOG_DIR")
             if env_dir:
                 self._log_dir = Path(env_dir)
-        
+
         # Debug logging is ON by default. Set SCRY_DEBUG=0 to disable.
         debug_env = os.environ.get("SCRY_DEBUG", "").lower()
         self._enabled = debug_env not in ("0", "false", "no", "off")
-    
+
     @property
     def log_dir(self) -> Path:
-        """Get log directory, with fallback to cwd."""
+        """Get log directory, with fallback to ~/.scry-run/logs/."""
         if self._log_dir:
             return self._log_dir
-        return Path.cwd()
+        # Fallback to global scry-run logs directory (not cwd)
+        fallback = Path.home() / ".scry-run" / "logs"
+        fallback.mkdir(parents=True, exist_ok=True)
+        return fallback
     
     @property  
     def log_file(self) -> Path:

scry_run/packages.py

@@ -60,6 +60,23 @@ def is_scry_run_installed(app_dir: Path) -> bool:
     return result.returncode == 0
 
 
+def has_required_runtime_deps(app_dir: Path) -> bool:
+    """Check if runtime dependencies for scry-run are installed in the app's venv."""
+    python_path = get_venv_python(app_dir)
+    if not python_path.exists():
+        return False
+
+    check = (
+        "import scry_run\n"
+        "import watchfiles\n"
+    )
+    result = subprocess.run(
+        [str(python_path), "-c", check],
+        capture_output=True,
+    )
+    return result.returncode == 0
+
+
 def ensure_scry_run_installed(app_dir: Path) -> None:
     """Ensure scry-run is installed in the app's virtual environment.
 
@@ -71,7 +88,7 @@ def ensure_scry_run_installed(app_dir: Path) -> None:
     """
     ensure_venv(app_dir)
 
-    if is_scry_run_installed(app_dir):
+    if is_scry_run_installed(app_dir) and has_required_runtime_deps(app_dir):
         return
 
     source_path = get_scry_run_source_path()
@@ -80,11 +97,11 @@ def ensure_scry_run_installed(app_dir: Path) -> None:
     if source_path:
         # Development mode - editable install from source
         status(f"Installing scry-run from source ({source_path.name})...")
-        cmd = ["uv", "pip", "install", "--python", str(python_path), "-e", str(source_path)]
+        cmd = ["uv", "pip", "install", "--upgrade", "--python", str(python_path), "-e", str(source_path)]
     else:
         # Production mode - install from PyPI
         status("Installing scry-run from PyPI...")
-        cmd = ["uv", "pip", "install", "--python", str(python_path), "scry-run"]
+        cmd = ["uv", "pip", "install", "--upgrade", "--python", str(python_path), "scry-run"]
 
     result = subprocess.run(cmd, capture_output=True, text=True)
     if result.returncode != 0:

{scry_run-0.1.1.dist-info → scry_run-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scry-run
-Version: 0.1.1
+Version: 0.2.0
 Summary: LLM-powered dynamic code generation via metaclasses. Define classes with docstrings, call any method—code generates automatically, caches persistently, and executes instantly.
 Project-URL: Homepage, https://github.com/Tener/scry-run
 Project-URL: Repository, https://github.com/Tener/scry-run
@@ -21,6 +21,7 @@ Requires-Dist: click>=8.0.0
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: watchfiles>=0.21.0
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
@@ -58,13 +59,17 @@ scry-run run todoist
 
 ## Demos
 
-### Creating a simple Hello World app
+### Greet app
 
-![Hello Demo](demos/hello.gif)
+[![Greet Demo](demos/out/greet.gif)](demos/out/greet.webm)
 
-### Building a maze game with PyGame
+### Timer app
 
-![Maze Demo](demos/maze.gif)
+[![Timer Demo](demos/out/timer.gif)](demos/out/timer.webm)
+
+### Maze app
+
+[![Maze Demo](demos/out/maze.gif)](demos/out/maze.webm)
 
 ## CLI Commands
 

{scry_run-0.1.1.dist-info → scry_run-0.2.0.dist-info}/RECORD

@@ -1,26 +1,27 @@
-scry_run/__init__.py,sha256=uAFNmvmMzEpsFNJ3Uew4RUSgNPXvn_cFkTU2Bx8RmWo,2875
+scry_run/__init__.py,sha256=T2IAIvDiA3Zz_qzDvQNwJrK2AdcwHhiJGW6Zz17PWAU,2875
 scry_run/cache.py,sha256=gzWNCRva4d1KOqrYx0eo0T9o8lbsBYmcxgnXPUfc9Dg,14163
-scry_run/config.py,sha256=zBnxbzHKwWDpg0C1BmSm6SGv5PF7rq_cSctWIsm_oz0,4083
-scry_run/console.py,sha256=1lVWZ-7tfbapl1wSYZ7zOWBwgKSn6LgR0QZYneILsgQ,2044
+scry_run/config.py,sha256=TsbmoNJCA_bZxYVtlCRZ2IIavzoWgRvFNPYKtsrKxrY,3970
+scry_run/console.py,sha256=Nk9rN5_dFb7QrCuDHEU0YrP5sfWnluwKQ30UtcRjV0E,3589
 scry_run/context.py,sha256=os3kdrYxcgzrkPPiPzIy9Lrlp4b964eishDb7KSCaCY,10256
 scry_run/generator.py,sha256=GjDGBgbes58L4Amo-tuXodfs7Tx2vGn_CO1YVdJMVjo,26422
 scry_run/home.py,sha256=-ZOgvsaJ0udH_a0_A0YYBZHjtLzGMVaU_t5NqmcBNIQ,1364
-scry_run/logging.py,sha256=zKB_-IgRT9GXVULaFJKepX4oUVXQlt3buqjzBoh9Uyo,5684
+scry_run/logging.py,sha256=58xegPlh6nD7iE-UR-HtVC-UPqAqhseCkORhtRjHBYY,5838
 scry_run/meta.py,sha256=shKzrDc-lUWIS8MOjouoVzPuOt3rP5zpWv5BvjIGWC4,71598
-scry_run/packages.py,sha256=U6HxWoEkFisKwLAeM_RtFvTt2qrCmxmZD38pJNVQt7g,5156
+scry_run/packages.py,sha256=obZythlwYOirrSYxS9bXGPP6hJOHxpcI_W3o3-Sizc4,5678
 scry_run/backends/__init__.py,sha256=q52KwLy2KsJLxpUJKbLsCTH0ELLLQGOz_14OnhDYOig,245
 scry_run/backends/base.py,sha256=bedYMpVL19dE_ei85wWRj8g5zsJsH607G8nAgsDpfwI,1693
 scry_run/backends/claude.py,sha256=fqYK1F1PsqCM2-ssvmdduhwjrsVURcLeCTJLxTbAKPE,15038
 scry_run/backends/frozen.py,sha256=69vqlztysFXuX7Nv5nu-bDqhan8F-0mHgGCC_4kOiQA,2912
 scry_run/backends/registry.py,sha256=pAOrZcaWHJhIn6ai-O6lBzb0QeICa3MV-kH5zcDcRrM,2180
-scry_run/cli/__init__.py,sha256=Hje8gmqzBsbX5iW6lKVfv5ZOXamkUVx-fGnwRupgmuU,5385
+scry_run/cli/__init__.py,sha256=GXpl__TEX099JhMCLDYN7odR3Xpw77vynKdJab3AcTY,5460
 scry_run/cli/apps.py,sha256=AP016GpSH4_mPpXq3k8r4hjBE5Kizxk9mDQNZpdAt0c,12609
 scry_run/cli/cache.py,sha256=UkxSFZUqiyDxn2KrFojh8UT03d_lBxJmolsV7w7qTmU,10774
 scry_run/cli/config_cmd.py,sha256=Ge8Xw8R3_LpEfCOrXgaeD-0KG4WrVslMpNdZhtReOp8,2436
 scry_run/cli/env.py,sha256=Jxw5I6TY5sJ0Rsha86OZDPRHDS850FA4n30sg4yFKhQ,745
-scry_run/cli/init.py,sha256=awBdgL0gILM5RJBKp2ZfuvkqmMdew_drAPRqq5QSrRw,13509
-scry_run/cli/run.py,sha256=vH89DttVCQwNWWwvUNxo9IbjnCGU2F_1OeWrMxHsvc8,2327
-scry_run-0.1.1.dist-info/METADATA,sha256=gZKL-lU4-KH79pCG0hFXnW7WsMtt7ovQ92s9INCvm_A,2651
-scry_run-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-scry_run-0.1.1.dist-info/entry_points.txt,sha256=edV5nv1PT_pjWsOcLR3DMNkV-MUBsCY-jORR4dee-Ho,47
-scry_run-0.1.1.dist-info/RECORD,,
+scry_run/cli/init.py,sha256=D8jijsY9kI0NAUln8uHaxb3eh2PlS7ao0XAm3AsR40E,16135
+scry_run/cli/log.py,sha256=4zbOR-IPBYrBou2Vumrpx7acxM3LnFc7J9PKWoXVgZk,10614
+scry_run/cli/run.py,sha256=JjgRl6_JCEc3LGEHYkvgRDuYaCTF4mQ95vlXWiwzjxs,3525
+scry_run-0.2.0.dist-info/METADATA,sha256=WP2TVmNOzD7jn69Uui1xjbcQITnIvdWOQZN49AbXCFw,2767
+scry_run-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+scry_run-0.2.0.dist-info/entry_points.txt,sha256=edV5nv1PT_pjWsOcLR3DMNkV-MUBsCY-jORR4dee-Ho,47
+scry_run-0.2.0.dist-info/RECORD,,