scry-run 0.1.0__py3-none-any.whl

scry_run/packages.py

@@ -0,0 +1,175 @@
+"""Package management utilities for per-app environments."""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+from scry_run.console import status, success, error, warning
+
+
+def get_venv_python(app_dir: Path) -> Path:
+    """Get path to Python executable in venv, cross-platform.
+
+    Args:
+        app_dir: Path to the app directory
+
+    Returns:
+        Path to the Python executable in the app's venv
+    """
+    if sys.platform == "win32":
+        return app_dir / ".venv" / "Scripts" / "python.exe"
+    return app_dir / ".venv" / "bin" / "python"
+
+
+def get_scry_run_source_path() -> Optional[Path]:
+    """Get the source path if scry-run is installed in development mode.
+
+    Returns:
+        Path to source directory if dev install, None if PyPI install
+    """
+    import scry_run
+    package_path = Path(scry_run.__file__).parent
+    # Go up to the project root (src/scry_run -> src -> project_root)
+    project_root = package_path.parent.parent
+    
+    # Check if we're in development mode (can access pyproject.toml and src/)
+    if (project_root / "pyproject.toml").exists() and (project_root / "src" / "scry_run").exists():
+        return project_root
+
+    return None
+
+
+def is_scry_run_installed(app_dir: Path) -> bool:
+    """Check if scry-run is installed in the app's venv.
+
+    Args:
+        app_dir: Path to the app directory
+
+    Returns:
+        True if scry-run is available in the app's venv
+    """
+    python_path = get_venv_python(app_dir)
+    if not python_path.exists():
+        return False
+
+    result = subprocess.run(
+        [str(python_path), "-c", "import scry_run"],
+        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.
+
+    In development mode (source install), installs from local path with -e.
+    In production mode (PyPI install), installs from PyPI.
+
+    Args:
+        app_dir: Path to the app directory
+    """
+    ensure_venv(app_dir)
+
+    if is_scry_run_installed(app_dir):
+        return
+
+    source_path = get_scry_run_source_path()
+    python_path = get_venv_python(app_dir)
+
+    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)]
+    else:
+        # Production mode - install from PyPI
+        status("Installing scry-run from PyPI...")
+        cmd = ["uv", "pip", "install", "--python", str(python_path), "scry-run"]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        error(f"Failed to install scry-run: {result.stderr}")
+        raise RuntimeError(f"Failed to install scry-run: {result.stderr}")
+
+    success("Installed scry-run")
+
+
+def ensure_venv(app_dir: Path) -> None:
+    """Ensure a virtual environment exists for the app.
+
+    Args:
+        app_dir: Path to the app directory
+    """
+    venv_path = app_dir / ".venv"
+    if venv_path.exists():
+        return
+
+    status(f"Creating virtual environment in {app_dir.name}...")
+    result = subprocess.run(
+        ["uv", "venv"],
+        cwd=app_dir,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        error(f"Failed to create venv: {result.stderr}")
+        raise RuntimeError(f"uv venv failed: {result.stderr}")
+
+
+def install_packages(app_dir: Path, packages: list[str]) -> None:
+    """Install packages into the app's virtual environment.
+
+    Args:
+        app_dir: Path to the app directory
+        packages: List of package specs (e.g., ["pygame", "requests>=2.0"])
+    """
+    if not packages:
+        return
+
+    # Ensure venv exists
+    ensure_venv(app_dir)
+
+    status(f"Installing packages: {', '.join(packages)}")
+    python_path = get_venv_python(app_dir)
+    result = subprocess.run(
+        ["uv", "pip", "install", "--python", str(python_path)] + packages,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        error(f"Failed to install packages: {result.stderr}")
+        raise RuntimeError(f"uv pip install failed: {result.stderr}")
+
+    success(f"Installed {len(packages)} package(s)")
+
+
+def get_installed_packages(app_dir: Path) -> list[str]:
+    """Get list of installed packages in the app's environment.
+
+    Args:
+        app_dir: Path to the app directory
+
+    Returns:
+        List of "package==version" strings
+    """
+    venv_path = app_dir / ".venv"
+    if not venv_path.exists():
+        return []
+
+    python_path = get_venv_python(app_dir)
+    result = subprocess.run(
+        ["uv", "pip", "list", "--format=freeze", "--python", str(python_path)],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        warning(f"Failed to list packages in {app_dir.name}")
+        return []
+
+    packages = []
+    for line in result.stdout.strip().split("\n"):
+        line = line.strip()
+        if line and not line.startswith("#"):
+            packages.append(line)
+
+    return packages

scry_run-0.1.0.dist-info/METADATA

@@ -0,0 +1,282 @@
+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

scry_run-0.1.0.dist-info/RECORD

@@ -0,0 +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/context.py,sha256=os3kdrYxcgzrkPPiPzIy9Lrlp4b964eishDb7KSCaCY,10256
+scry_run/generator.py,sha256=KrlfdwwDyp5DRRTD9vPRUkweWGAMU85z2EnjznKLXj4,25023
+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/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/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/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.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

scry_run-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scry-run = scry_run.cli:main