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

scry_run/backends/frozen.py

@@ -1,7 +1,7 @@
 """Frozen backend - errors on any generation attempt.
 
-This backend is used for "baked" apps that should only use cached methods.
-Any attempt to generate new code will raise FrozenAppError.
+This backend is used when code generation should be disabled and only cached methods
+should be used. Any attempt to generate new code will raise FrozenAppError.
 """
 
 from typing import Optional
@@ -14,8 +14,8 @@ class FrozenAppError(RuntimeError):
     """Raised when a frozen app attempts to generate code.
 
     This error indicates that a method was called that doesn't exist
-    in the cache of a baked/frozen app. The app needs to be "unbaked"
-    or the method needs to be added to the cache before baking.
+    in the cache of a frozen app. The backend needs to be changed to allow
+    generation, or the method needs to be pre-generated and cached.
     """
 
     def __init__(self, class_name: str, attr_name: str):
@@ -24,7 +24,7 @@ class FrozenAppError(RuntimeError):
         super().__init__(
             f"Frozen app cannot generate code for '{class_name}.{attr_name}'. "
             f"This method is not in the cache. Either:\n"
-            f"  1. Run the original app to generate this method, then re-bake\n"
+            f"  1. Run the app with a real backend to generate this method first\n"
             f"  2. Set _llm_backend to a real backend (e.g., 'claude') to unfreeze"
         )
 
@@ -32,7 +32,7 @@ class FrozenAppError(RuntimeError):
 class FrozenBackend(GeneratorBackend):
     """Backend that refuses to generate any code.
 
-    Used for baked apps where all methods should come from cache.
+    Used when all methods should come from cache and generation is disabled.
     Any generation attempt raises FrozenAppError with helpful message.
     """
 

scry_run/cli/init.py

@@ -370,6 +370,5 @@ def init(
     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")
     console.print(f"  [cyan]scry-run cache list {name}[/cyan]  List generated methods")
-    console.print(f"  [cyan]scry-run bake {name}[/cyan]        Export as standalone package")
     console.print()
     console.print("[dim]Methods are generated on first use using Claude CLI.[/dim]")

scry_run/console.py

@@ -1,52 +1,59 @@
 """Console output utilities for consistent styling."""
 
+from datetime import datetime
+
 from rich.console import Console
 
 # Stderr console for status messages
 err_console = Console(stderr=True, highlight=False)
 
 
+def _timestamp() -> str:
+    """Return current time as HH:MM:SS."""
+    return datetime.now().strftime("%H:%M:%S")
+
+
 def status(msg: str) -> None:
     """Print a dim status message."""
-    err_console.print(f"[dim]\\[scry-run][/dim] {msg}")
+    err_console.print(f"[dim]{_timestamp()} \\[scry-run][/dim] {msg}")
 
 
 def info(msg: str) -> None:
     """Print an info message (cyan)."""
-    err_console.print(f"[cyan]\\[scry-run][/cyan] {msg}")
+    err_console.print(f"[dim]{_timestamp()}[/dim] [cyan]\\[scry-run][/cyan] {msg}")
 
 
 def success(msg: str) -> None:
     """Print a success message (green)."""
-    err_console.print(f"[green]\\[scry-run][/green] {msg}")
+    err_console.print(f"[dim]{_timestamp()}[/dim] [green]\\[scry-run][/green] {msg}")
 
 
 def warning(msg: str) -> None:
     """Print a warning message (yellow)."""
-    err_console.print(f"[yellow]\\[scry-run][/yellow] {msg}")
+    err_console.print(f"[dim]{_timestamp()}[/dim] [yellow]\\[scry-run][/yellow] {msg}")
 
 
 def error(msg: str) -> None:
     """Print an error message (red)."""
-    err_console.print(f"[red]\\[scry-run][/red] {msg}")
+    err_console.print(f"[dim]{_timestamp()}[/dim] [red]\\[scry-run][/red] {msg}")
 
 
 def generating(class_name: str, attr_name: str) -> None:
     """Print a 'generating' message."""
-    err_console.print(f"[cyan]\\[scry-run][/cyan] Generating {class_name}.{attr_name}...")
+    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."""
-    err_console.print(f"[green]\\[scry-run][/green] Generated {class_name}.{attr_name} ✓")
+    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."""
-    err_console.print(f"[dim]\\[scry-run][/dim] Using cached {class_name}.{attr_name}")
+    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."""
     model_str = f" (model={model})" if model else ""
-    err_console.print(f"[dim]\\[scry-run][/dim] Using backend: {backend_name}{model_str} ({reason})")
+    err_console.print(f"[dim]{_timestamp()} \\[scry-run][/dim] Using backend: {backend_name}{model_str} ({reason})")

scry_run/generator.py

@@ -603,8 +603,31 @@ IMPORTANT: Output ONLY the JSON object, no markdown, no explanation, no code fen
 
         # Delegate to backend with retries
         last_error: Optional[Exception] = None
+        previous_errors: list[str] = []  # Track errors for feedback
 
         for attempt in range(self.MAX_RETRIES):
+            # Build error feedback for retry attempts
+            error_feedback = ""
+            if previous_errors:
+                error_feedback = f"""
+
+## PREVIOUS GENERATION FAILED
+
+This is generation attempt #{attempt + 1}. Previous attempt(s) caused errors:
+
+{chr(10).join(f"- Attempt #{i+1}: {err}" for i, err in enumerate(previous_errors))}
+
+Please analyze these errors and generate FIXED code that avoids them.
+"""
+
+            # Rebuild prompt with error feedback if needed
+            if error_feedback:
+                if supports_context:
+                    prompt = self._build_frame_prompt(class_name, attr_name, is_classmethod, runtime_context + error_feedback)
+                else:
+                    prompt = self._build_prompt(context + error_feedback, class_name, attr_name, is_classmethod, installed_packages)
+                logger.log_generation_start(class_name, attr_name, prompt)
+
             try:
                 result = self._backend.generate_code(prompt)
                 
@@ -645,7 +668,15 @@ IMPORTANT: Output ONLY the JSON object, no markdown, no explanation, no code fen
                 # Log the validation error with full details
                 code_str = result.code if 'result' in dir() and hasattr(result, 'code') else None
                 logger.log_validation_error(e, code_str)
-                
+
+                # Track error for feedback on next attempt
+                error_msg = f"{type(e).__name__}: {e}"
+                if code_str:
+                    # Include a snippet of the problematic code
+                    code_preview = code_str[:200] + "..." if len(code_str) > 200 else code_str
+                    error_msg += f"\n  Generated code (preview): {code_preview}"
+                previous_errors.append(error_msg)
+
                 if attempt >= self.MAX_RETRIES - 1:
                     raise
                 warning(f"Validation error, retrying ({attempt + 1}/{self.MAX_RETRIES})...")

scry_run/meta.py

@@ -995,6 +995,7 @@ Requirements:
         MAX_RETRIES = 3
         last_error = None
         current_context = call_context
+        previous_errors: list[str] = []  # Track all errors for accumulated feedback
 
         for attempt in range(MAX_RETRIES + 1):
             # Generate code
@@ -1035,28 +1036,28 @@ Requirements:
                     # Invalidate cache so _llm_generate actually generates new code
                     self._cls._get_cache().prune(self._cls.__name__, self._name)
 
-                    # Update context with error feedback
+                    # Track this error
                     if is_signature_error:
-                         error_feedback = f"""
-## CRITICAL ERROR - SIGNATURE MISMATCH
+                        previous_errors.append(f"Attempt #{attempt + 1} - TypeError (signature mismatch): {e}")
+                    else:
+                        previous_errors.append(f"Attempt #{attempt + 1} - {type(e).__name__}: {e}")
 
-You previously generated code that caused this error when called:
-TypeError: {e}
+                    # Build accumulated error feedback
+                    errors_list = chr(10).join(f"  {err}" for err in previous_errors)
+                    error_feedback = f"""
+## CRITICAL - PREVIOUS GENERATION FAILED
 
-The code was called with:
-{chr(10).join(args_desc) if args_desc else "No arguments ()"}
+This is generation attempt #{attempt + 2}. Previous attempt(s) caused errors:
 
-You MUST fix the signature to match exactly how it is called.
-"""
-                    else:
-                        error_feedback = f"""
-## CRITICAL ERROR - RUNTIME EXCEPTION
+{errors_list}
 
-You previously generated code that crashed with this error when executed:
-{type(e).__name__}: {e}
+The code was called with:
+{chr(10).join(args_desc) if args_desc else "No arguments ()"}
 
-This error occurred INSIDE your generated code.
-Please analyze the error and FIX the code to handle this case.
+You MUST analyze ALL previous errors and generate FIXED code that:
+1. Has the correct signature matching how it is called
+2. Handles edge cases that caused runtime exceptions
+3. Does NOT repeat the same mistakes
 """
 
                     current_context = call_context + error_feedback
@@ -1356,7 +1357,7 @@ class ScryClass(metaclass=ScryMeta):
     _llm_cache: Optional["ScryCache"] = None
     _llm_generator: Optional["CodeGenerator"] = None
     _llm_model: Optional[str] = None  # Model override (e.g., "opus" for Claude)
-    _llm_backend: Optional[str] = None  # Backend override (e.g., "frozen" for baked apps)
+    _llm_backend: Optional[str] = None  # Backend override (e.g., "frozen" to prevent generation)
     _llm_use_full_context: bool = True
     _llm_quiet: bool = False  # Set to True to suppress generation messages
 

scry_run-0.1.1.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: scry-run
+Version: 0.1.1
+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
+Author: Krzysztof Skrzętnicki
+License: MIT
+Keywords: ai,claude,code-generation,llm,metaclass
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Requires-Dist: claude-agent-sdk>=0.1.0
+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'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# scry-run
+
+**Describe an app, run it.** A CLI tool that generates and runs Python applications from natural language descriptions.
+
+## Installation
+
+```bash
+uv tool install scry-run
+```
+
+Or run without installing:
+
+```bash
+uvx scry-run --help
+```
+
+Requires [Claude Code CLI](https://github.com/anthropics/claude-code) to be installed.
+
+## Quick Start
+
+```bash
+# Create an app
+scry-run init --name=todoist --description='minimal web todo app'
+
+# Run it
+scry-run run todoist
+```
+
+## Demos
+
+### Creating a simple Hello World app
+
+![Hello Demo](demos/hello.gif)
+
+### Building a maze game with PyGame
+
+![Maze Demo](demos/maze.gif)
+
+## CLI Commands
+
+```bash
+# Create a new app
+scry-run init --name=NAME --description=DESC
+
+# List all apps
+scry-run list
+
+# Run an app
+scry-run run myapp [args...]
+
+# Get app info
+scry-run info myapp
+scry-run which myapp
+
+# Remove or reset an app
+scry-run rm myapp
+scry-run reset myapp
+
+# Cache management
+scry-run cache list myapp
+scry-run cache show myapp MyClass.method
+scry-run cache export myapp --output=code.py
+scry-run cache prune myapp --all
+```
+
+## Configuration
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `SCRY_RUN_BACKEND` | Backend: `claude`, `frozen`, or `auto` | `auto` |
+| `SCRY_RUN_MODEL` | Model override (e.g., `opus`) | (backend default) |
+
+## License
+
+MIT

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

@@ -1,26 +1,26 @@
 scry_run/__init__.py,sha256=uAFNmvmMzEpsFNJ3Uew4RUSgNPXvn_cFkTU2Bx8RmWo,2875
 scry_run/cache.py,sha256=gzWNCRva4d1KOqrYx0eo0T9o8lbsBYmcxgnXPUfc9Dg,14163
 scry_run/config.py,sha256=zBnxbzHKwWDpg0C1BmSm6SGv5PF7rq_cSctWIsm_oz0,4083
-scry_run/console.py,sha256=r8IO8zw5A132Yqik3Y2K2IzbFLNW3hFcyhGo1bup2Yk,1695
+scry_run/console.py,sha256=1lVWZ-7tfbapl1wSYZ7zOWBwgKSn6LgR0QZYneILsgQ,2044
 scry_run/context.py,sha256=os3kdrYxcgzrkPPiPzIy9Lrlp4b964eishDb7KSCaCY,10256
-scry_run/generator.py,sha256=KrlfdwwDyp5DRRTD9vPRUkweWGAMU85z2EnjznKLXj4,25023
+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/meta.py,sha256=z71xDV91pEi2-SG3MD-_SFwkWEHdgDMvbaQyxYHgCR4,71310
+scry_run/meta.py,sha256=shKzrDc-lUWIS8MOjouoVzPuOt3rP5zpWv5BvjIGWC4,71598
 scry_run/packages.py,sha256=U6HxWoEkFisKwLAeM_RtFvTt2qrCmxmZD38pJNVQt7g,5156
 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=DfPWpD0Yq5wV5-kQtEGAuRWfv1q4Z66MPpmPIs-ZbEw,2863
+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/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=DsWyzE1qN6gYMwHhGljIhp-mpMn4xODFQ2bSLJt1ELM,13603
+scry_run/cli/init.py,sha256=awBdgL0gILM5RJBKp2ZfuvkqmMdew_drAPRqq5QSrRw,13509
 scry_run/cli/run.py,sha256=vH89DttVCQwNWWwvUNxo9IbjnCGU2F_1OeWrMxHsvc8,2327
-scry_run-0.1.0.dist-info/METADATA,sha256=lVPhCXWZSZPuSZWt3hT83vSSgfqA3DPkxvri8WXRFF8,6969
-scry_run-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-scry_run-0.1.0.dist-info/entry_points.txt,sha256=edV5nv1PT_pjWsOcLR3DMNkV-MUBsCY-jORR4dee-Ho,47
-scry_run-0.1.0.dist-info/RECORD,,
+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-0.1.0.dist-info/METADATA

@@ -1,282 +0,0 @@
-Metadata-Version: 2.4
-Name: scry-run
-Version: 0.1.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
-Author: Krzysztof Skrzętnicki
-License: MIT
-Keywords: ai,claude,code-generation,llm,metaclass
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Code Generators
-Requires-Python: >=3.10
-Requires-Dist: claude-agent-sdk>=0.1.0
-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'
-Provides-Extra: dev
-Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
-Requires-Dist: pytest-timeout>=2.0.0; extra == 'dev'
-Requires-Dist: pytest>=7.0.0; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# scry-run
-
-**Write class definitions, get working code.** A Python library where any method call automatically generates its implementation via LLM.
-
-Define your application as a class with a docstring, then call any method you want—`scry-run` generates the code on-demand, caches it, and executes it. No boilerplate, no implementation required.
-
-## Features
-
-- **Zero-boilerplate coding**: Define intent via class docstrings, methods generate automatically
-- **Intelligent caching**: Generated code persists across runs—pay once, use forever
-- **Production-ready**: Bake apps into standalone packages with frozen, pre-generated code
-- **CLI-first**: Manage apps, inspect cache, and export generated code via intuitive commands
-
-## Installation
-
-```bash
-pip install scry-run
-# or with uv
-uv pip install scry-run
-```
-
-### Run without installing (uvx)
-
-```bash
-# From PyPI
-uvx scry-run --help
-uvx scry-run init --name=myapp --description="My app"
-
-# From GitHub (latest)
-uvx --from git+https://github.com/scry-run/scry-run scry-run --help
-```
-
-## Quick Start
-
-### 1. Set up your backend
-
-Requires Claude Code CLI to be installed.
-
-```bash
-# Verify claude CLI is available
-claude --version
-```
-
-### 2. Initialize a project
-
-```bash
-# Non-interactive
-scry-run init --name=todoist --description='minimal web todo app'
-
-# Interactive
-scry-run init
-```
-
-### 3. Run your app
-
-```bash
-scry-run run todoist
-```
-
-Or use it directly in Python:
-
-```python
-from scry_run import ScryClass
-
-class Todoist(ScryClass):
-    """A minimal web todo app with task management."""
-    pass
-
-app = Todoist()
-
-# These methods will be generated automatically!
-app.add_task("Buy groceries")
-app.list_tasks()
-app.complete_task(0)
-```
-
-## Demos
-
-### Creating a simple Hello World app
-
-![Hello Demo](demos/hello.gif)
-
-### Building a maze game with PyGame
-
-![Maze Demo](demos/maze.gif)
-
-
-## How It Works
-
-1. When you access an undefined attribute on an `ScryClass` subclass, the metaclass intercepts it
-2. The library collects the full codebase context and builds a prompt
-3. The configured backend generates code with structured JSON output (code, type, docstring, dependencies)
-4. The code is validated with Python's `ast.parse()` to ensure it's syntactically correct
-5. Valid code is cached and executed
-6. On subsequent accesses, the cached code is used directly
-
-## Backend
-
-Uses Claude Code CLI with `--print` flag for non-interactive output.
-
-```bash
-# If claude CLI is installed, it's used automatically
-scry-run run myapp
-
-# Optionally specify a model
-export SCRY_RUN_MODEL=opus
-```
-
-## Configuration
-
-### Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `SCRY_RUN_BACKEND` | Backend to use: `claude`, `frozen`, or `auto` | `auto` |
-| `SCRY_RUN_MODEL` | Model override (e.g., `opus`) | (backend default) |
-| `SCRY_RUN_MAX_GENERATIONS` | Max code generations per process | `100` |
-
-### Class-level options
-
-```python
-class MyApp(ScryClass):
-    """My application."""
-
-    # Disable LLM generation (raises AttributeError for missing attrs)
-    _llm_enabled = False
-
-    # Use minimal context instead of full codebase (faster)
-    _llm_use_full_context = False
-
-    # Suppress generation messages
-    _llm_quiet = True
-
-    # Override model for this class
-    _llm_model = "opus"
-```
-
-## CLI Commands
-
-### App Management
-
-```bash
-# Initialize a new app
-scry-run init --name=NAME --description=DESC
-
-# List all apps
-scry-run list
-
-# Get path to an app's main file
-scry-run which myapp
-
-# Run an app
-scry-run run myapp [args...]
-
-# Remove an app
-scry-run rm myapp
-scry-run rm myapp --force  # Skip confirmation
-
-# Reset an app (clear code & cache, keep name/description)
-scry-run reset myapp
-scry-run reset myapp --force  # Skip confirmation
-```
-
-### Cache Management
-
-```bash
-# List cached entries for an app
-scry-run cache list myapp
-
-# Show a specific entry
-scry-run cache show myapp MyClass.my_method
-
-# Export cache
-scry-run cache export myapp --output=generated.py --format=python
-scry-run cache export myapp --output=cache.json --format=json
-
-# Remove a specific entry
-scry-run cache rm myapp MyClass.my_method
-
-# Prune cache entries
-scry-run cache prune myapp --class=MyClass --attr=my_method
-scry-run cache prune myapp --class=MyClass  # All methods of a class
-scry-run cache prune myapp --all            # Everything
-
-# Reset cache (clear all entries)
-scry-run cache reset myapp --force
-```
-
-## API
-
-### ScryClass
-
-Base class to inherit from for LLM-powered code generation.
-
-```python
-from scry_run import ScryClass
-
-class MyApp(ScryClass):
-    """Description of your app - the LLM uses this!"""
-
-    def existing_method(self):
-        """Existing methods are used as context."""
-        return "hello"
-
-# Class methods
-MyApp.llm_export_cache("output.py")  # Export generated code
-MyApp.llm_prune_cache("method_name") # Remove cached entry
-MyApp.llm_disable()                   # Disable generation
-MyApp.llm_enable()                    # Re-enable generation
-```
-
-### ScryCache
-
-Manage the code cache programmatically.
-
-```python
-from scry_run import ScryCache
-
-cache = ScryCache()
-
-# Get cached code
-entry = cache.get("MyClass", "my_method")
-print(entry.code)
-
-# List all entries
-for entry in cache.list_entries():
-    print(f"{entry.class_name}.{entry.attr_name}: {entry.docstring}")
-
-# Export
-cache.export_to_file("all_generated_code.py")
-
-# Prune
-cache.prune(class_name="MyClass", attr_name="my_method")
-```
-
-## Development
-
-```bash
-# Clone the repo
-git clone https://github.com/scry-run/scry-run
-cd scry-run
-
-# Install with dev dependencies
-uv sync --dev
-
-# Run tests
-uv run pytest tests/ -v
-```
-
-## License
-
-MIT