scry-run 0.1.2__tar.gz → 0.2.0__tar.gz

scry_run-0.2.0/.claude/settings.local.json

@@ -0,0 +1,20 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(wc:*)",
+      "Bash(uv run pytest:*)",
+      "Bash(uv run python -m pytest:*)",
+      "Bash(uv sync:*)",
+      "Bash(uv lock:*)",
+      "Bash(uv run:*)",
+      "Bash(SCRY_BACKEND=claude uv run:*)",
+      "Bash(SCRY_RUN_HOME=/tmp/test_scry_home uv run:*)",
+      "Bash(SCRY_HOME=/tmp/test_scry_home uv run scry-run:*)",
+      "Bash(SCRY_HOME=/tmp/test_scry_home SCRY_MODEL=haiku uv run:*)",
+      "Bash(vhs:*)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:raw.githubusercontent.com)"
+    ]
+  }
+}

{scry_run-0.1.2 → scry_run-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scry-run
-Version: 0.1.2
+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.2 → scry_run-0.2.0}/README.md

@@ -28,13 +28,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.2 → scry_run-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scry-run"
-version = "0.1.2"
+version = "0.2.0"
 description = "LLM-powered dynamic code generation via metaclasses. Define classes with docstrings, call any method—code generates automatically, caches persistently, and executes instantly."
 readme = "README.md"
 license = { text = "MIT" }
@@ -24,6 +24,7 @@ dependencies = [
     "jinja2>=3.0.0",
     "tomli>=2.0.0;python_version<'3.11'",
     "claude-agent-sdk>=0.1.0",
+    "watchfiles>=0.21.0",
 ]
 
 [project.optional-dependencies]

{scry_run-0.1.2 → scry_run-0.2.0}/src/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-0.1.2 → scry_run-0.2.0}/src/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-0.1.2 → scry_run-0.2.0}/src/scry_run/cli/init.py

@@ -278,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.
 
@@ -343,26 +350,30 @@ def init(
 
             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":
+            # Auto-approve or let user confirm
+            if yes:
                 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
+                # 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]")
 
@@ -379,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)
 

scry_run-0.2.0/src/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-0.1.2 → scry_run-0.2.0}/src/scry_run/cli/run.py

@@ -10,6 +10,7 @@ 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()
 
@@ -87,9 +88,20 @@ def run(ctx, quiet: bool, 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-0.1.2 → scry_run-0.2.0}/src/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-0.1.2 → scry_run-0.2.0}/src/scry_run/console.py

@@ -24,9 +24,17 @@ def _set_title(msg: str) -> None:
     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: