scry-run 0.1.0__py3-none-any.whl

scry_run/backends/registry.py

@@ -0,0 +1,72 @@
+"""Backend registry and auto-detection."""
+
+import os
+from typing import Optional, Type
+
+from scry_run.backends.base import GeneratorBackend
+from scry_run.console import backend_selected
+
+
+# Registry of available backends
+_backends: dict[str, Type[GeneratorBackend]] = {}
+
+# Auto-detection order (first available wins)
+AUTO_DETECT_ORDER = ["claude"]
+
+
+def register_backend(name: str, backend_cls: Type[GeneratorBackend]) -> None:
+    """Register a backend class.
+
+    Args:
+        name: Backend name (e.g., "cli", "api")
+        backend_cls: The backend class
+    """
+    _backends[name] = backend_cls
+
+
+def get_backend(
+    name: Optional[str] = None,
+    model: Optional[str] = None,
+) -> GeneratorBackend:
+    """Get a backend instance.
+
+    Args:
+        name: Backend name to use. If None, auto-detect.
+              Options: "claude", "frozen", "auto"
+        model: Model name to use (backend-specific)
+
+    Returns:
+        Configured backend instance
+
+    Raises:
+        ValueError: If specified backend not found or unavailable
+    """
+    # Import backends here to trigger registration
+    from scry_run.backends import claude, frozen
+
+    # Check env var first
+    env_backend = os.environ.get("SCRY_BACKEND", "").lower()
+    if env_backend and name is None:
+        name = env_backend
+
+    # Auto-detect: try backends in priority order
+    if name is None or name == "auto":
+        for backend_name in AUTO_DETECT_ORDER:
+            if backend_name in _backends and _backends[backend_name].is_available():
+                backend_selected(backend_name, model, "auto-detected")
+                return _backends[backend_name](model=model)
+        raise ValueError(
+            "No available backend. Install claude CLI."
+        )
+
+    # Specific backend requested
+    if name not in _backends:
+        raise ValueError(f"Unknown backend: {name}. Available: {list(_backends.keys())}")
+
+    backend_cls = _backends[name]
+    if not backend_cls.is_available():
+        raise ValueError(f"Backend '{name}' is not available.")
+
+    reason = "from SCRY_BACKEND" if env_backend else "explicit"
+    backend_selected(name, model, reason)
+    return backend_cls(model=model)

scry_run/cache.py

@@ -0,0 +1,441 @@
+"""File-based cache for generated code."""
+
+from __future__ import annotations
+
+import json
+import hashlib
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class CacheEntry:
+    """A single cached code entry."""
+
+    class_name: str
+    attr_name: str
+    code: str
+    code_type: str  # method, property, classmethod, staticmethod
+    docstring: str
+    dependencies: list[str]
+    created_at: str
+    checksum: str  # SHA256 of the code
+    packages: list[str] = None  # PyPI packages
+
+    def __post_init__(self):
+        if self.packages is None:
+            self.packages = []
+
+    @classmethod
+    def create(
+        cls,
+        class_name: str,
+        attr_name: str,
+        code: str,
+        code_type: str = "method",
+        docstring: str = "",
+        dependencies: list[str] | None = None,
+        packages: list[str] | None = None,
+    ) -> CacheEntry:
+        """Create a new cache entry with auto-generated metadata."""
+        return cls(
+            class_name=class_name,
+            attr_name=attr_name,
+            code=code,
+            code_type=code_type,
+            docstring=docstring,
+            dependencies=dependencies or [],
+            created_at=datetime.now().isoformat(),
+            checksum=hashlib.sha256(code.encode()).hexdigest(),
+            packages=packages or [],
+        )
+
+
+class ScryCache:
+    """Manages the cache of generated code.
+
+    Supports two modes:
+    - Directory mode (legacy): Each class gets its own JSON file in a cache directory
+    - Single-file mode: All classes in one JSON file
+
+    Mode is auto-detected based on the path:
+    - If path ends with .json -> single-file mode
+    - If path is a directory (or no extension) -> directory mode
+    """
+
+    DEFAULT_CACHE_DIR = ".scry-run-cache"
+
+    DEFAULT_CACHE_DIR = ".scry-run-cache"
+    
+    def __init__(self, cache_path: str | Path | None = None, read_only: bool = False):
+
+        """Initialize cache with optional custom path.
+
+        Args:
+            cache_path: Path to cache directory or file.
+                       If ends with .json, uses single-file mode.
+                       Otherwise uses directory mode.
+                       Defaults to .scry-run-cache/ directory.
+            read_only: If True, prevents any modification to the cache.
+        """
+        self.read_only = read_only
+
+        if cache_path is None:
+            # Legacy mode: directory
+            self.cache_path = Path(self.DEFAULT_CACHE_DIR)
+            self._file_mode = False
+        else:
+            self.cache_path = Path(cache_path)
+            # File mode if path ends with .json
+            self._file_mode = self.cache_path.suffix == ".json"
+
+        # For backwards compatibility, expose cache_dir for directory mode
+        if not self._file_mode:
+            self.cache_dir = self.cache_path
+            self._ensure_cache_dir()
+
+    def _ensure_cache_dir(self) -> None:
+        """Create cache directory if it doesn't exist (directory mode only)."""
+        if not self._file_mode:
+            self.cache_path.mkdir(parents=True, exist_ok=True)
+
+    # === Single-file mode methods ===
+
+    def _load_all(self) -> dict[str, dict[str, dict]]:
+        """Load entire cache from single JSON file.
+
+        Returns:
+            Nested dict: {class_name: {attr_name: entry_data}}
+        """
+        if not self.cache_path.exists():
+            return {}
+
+        with open(self.cache_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    def _save_all(self, data: dict[str, dict[str, dict]]) -> None:
+        """Save entire cache to single JSON file.
+
+        Args:
+            data: Nested dict: {class_name: {attr_name: entry_data}}
+        """
+        # Ensure parent directory exists
+        self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(self.cache_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+    
+    # === Directory mode methods ===
+
+    def _get_class_cache_path(self, class_name: str) -> Path:
+        """Get the cache file path for a specific class (directory mode only)."""
+        return self.cache_path / f"{class_name}.json"
+
+    def _load_class_cache(self, class_name: str) -> dict[str, CacheEntry]:
+        """Load all cached entries for a class.
+
+        Works in both modes:
+        - Directory mode: loads from {class_name}.json
+        - Single-file mode: loads class section from cache.json
+        """
+        if self._file_mode:
+            all_data = self._load_all()
+            class_data = all_data.get(class_name, {})
+            return {
+                attr_name: CacheEntry(**entry_data)
+                for attr_name, entry_data in class_data.items()
+            }
+
+        # Directory mode
+        cache_path = self._get_class_cache_path(class_name)
+
+        if not cache_path.exists():
+            return {}
+
+        with open(cache_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        return {
+            attr_name: CacheEntry(**entry_data)
+            for attr_name, entry_data in data.items()
+        }
+
+    def _save_class_cache(self, class_name: str, entries: dict[str, CacheEntry]) -> None:
+        """Save all cached entries for a class.
+
+        Works in both modes:
+        - Directory mode: saves to {class_name}.json
+        - Single-file mode: saves class section to cache.json
+        """
+        data = {
+            attr_name: asdict(entry)
+            for attr_name, entry in entries.items()
+        }
+
+        if self._file_mode:
+            all_data = self._load_all()
+            all_data[class_name] = data
+            self._save_all(all_data)
+            return
+
+        # Directory mode
+        cache_path = self._get_class_cache_path(class_name)
+
+        with open(cache_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+    
+    def get(self, class_name: str, attr_name: str) -> Optional[CacheEntry]:
+        """Get a cached code entry.
+        
+        Args:
+            class_name: Name of the class
+            attr_name: Name of the attribute
+            
+        Returns:
+            CacheEntry if found, None otherwise
+        """
+        entries = self._load_class_cache(class_name)
+        return entries.get(attr_name)
+    
+    def set(
+        self,
+        class_name: str,
+        attr_name: str,
+        code: str,
+        code_type: str = "method",
+        docstring: str = "",
+        dependencies: list[str] | None = None,
+        packages: list[str] | None = None,
+    ) -> CacheEntry:
+        """Cache a code entry.
+
+        Args:
+            class_name: Name of the class
+            attr_name: Name of the attribute
+            code: The generated code
+            code_type: Type of code (method, property, etc.)
+            docstring: Description of the code
+            dependencies: List of import dependencies
+            packages: List of PyPI packages required
+
+        """
+        if self.read_only:
+             # In read-only mode, we pretend we set it but don't persist
+             # This allows runtime usage of generated code without saving
+            return CacheEntry.create(
+                class_name=class_name,
+                attr_name=attr_name,
+                code=code,
+                code_type=code_type,
+                docstring=docstring,
+                dependencies=dependencies,
+                packages=packages,
+            )
+
+        entries = self._load_class_cache(class_name)
+
+
+        entry = CacheEntry.create(
+            class_name=class_name,
+            attr_name=attr_name,
+            code=code,
+            code_type=code_type,
+            docstring=docstring,
+            dependencies=dependencies,
+            packages=packages,
+        )
+        
+        entries[attr_name] = entry
+        self._save_class_cache(class_name, entries)
+        
+        return entry
+    
+    def delete(self, class_name: str, attr_name: str) -> bool:
+        """Delete a cached entry.
+
+        Args:
+            class_name: Name of the class
+            attr_name: Name of the attribute
+
+        Returns:
+            True if entry was deleted, False if it didn't exist or read-only
+        """
+        if self.read_only:
+            return False
+
+        entries = self._load_class_cache(class_name)
+
+
+        if attr_name not in entries:
+            return False
+
+        del entries[attr_name]
+
+        if self._file_mode:
+            # Single-file mode: update the entire file
+            all_data = self._load_all()
+            if entries:
+                all_data[class_name] = {
+                    attr_name: asdict(entry)
+                    for attr_name, entry in entries.items()
+                }
+            else:
+                # Remove empty class from file
+                all_data.pop(class_name, None)
+            self._save_all(all_data)
+        else:
+            # Directory mode
+            if entries:
+                self._save_class_cache(class_name, entries)
+            else:
+                # Remove empty cache file
+                cache_path = self._get_class_cache_path(class_name)
+                cache_path.unlink(missing_ok=True)
+
+        return True
+    
+    def prune(
+        self,
+        class_name: Optional[str] = None,
+        attr_name: Optional[str] = None,
+    ) -> int:
+        """Prune cache entries.
+
+        Args:
+            class_name: If provided, only prune entries for this class
+            attr_name: If provided along with class_name, only prune this specific entry
+
+        Returns:
+            Number of entries pruned (0 if read-only)
+        """
+        if self.read_only:
+            return 0
+
+        pruned = 0
+
+
+        if class_name and attr_name:
+            # Prune specific entry
+            if self.delete(class_name, attr_name):
+                pruned = 1
+        elif class_name:
+            # Prune all entries for a class
+            entries = self._load_class_cache(class_name)
+            pruned = len(entries)
+
+            if self._file_mode:
+                # Single-file mode: remove class from file
+                all_data = self._load_all()
+                all_data.pop(class_name, None)
+                self._save_all(all_data)
+            else:
+                # Directory mode: remove class file
+                cache_path = self._get_class_cache_path(class_name)
+                cache_path.unlink(missing_ok=True)
+        else:
+            # Prune entire cache
+            if self._file_mode:
+                # Single-file mode: count entries and clear file
+                all_data = self._load_all()
+                for class_data in all_data.values():
+                    pruned += len(class_data)
+                self.cache_path.unlink(missing_ok=True)
+            else:
+                # Directory mode: remove all class files
+                for cache_file in self.cache_path.glob("*.json"):
+                    with open(cache_file, "r", encoding="utf-8") as f:
+                        data = json.load(f)
+                    pruned += len(data)
+                    cache_file.unlink()
+
+        return pruned
+    
+    def list_entries(self) -> list[CacheEntry]:
+        """List all cached entries.
+
+        Returns:
+            List of all CacheEntry objects in the cache
+        """
+        entries = []
+
+        if self._file_mode:
+            # Single-file mode: load all classes from one file
+            all_data = self._load_all()
+            for class_name, class_data in all_data.items():
+                for attr_name, entry_data in class_data.items():
+                    entries.append(CacheEntry(**entry_data))
+        else:
+            # Directory mode: load from each class file
+            for cache_file in self.cache_path.glob("*.json"):
+                class_name = cache_file.stem
+                class_entries = self._load_class_cache(class_name)
+                entries.extend(class_entries.values())
+
+        return entries
+    
+    def export(self) -> dict[str, dict[str, dict]]:
+        """Export entire cache as a dictionary.
+
+        Returns:
+            Nested dict: {class_name: {attr_name: entry_data}}
+        """
+        if self._file_mode:
+            # Single-file mode: just load and return the entire file
+            return self._load_all()
+
+        # Directory mode: aggregate from all class files
+        result = {}
+
+        for cache_file in self.cache_path.glob("*.json"):
+            class_name = cache_file.stem
+            with open(cache_file, "r", encoding="utf-8") as f:
+                result[class_name] = json.load(f)
+
+        return result
+    
+    def export_to_file(self, output_path: str | Path) -> None:
+        """Export cache to a Python file with all generated code.
+        
+        Args:
+            output_path: Path to write the Python file
+        """
+        output_path = Path(output_path)
+        entries = self.list_entries()
+        
+        # Collect all dependencies
+        all_deps = set()
+        for entry in entries:
+            all_deps.update(entry.dependencies)
+        
+        # Group entries by class
+        by_class: dict[str, list[CacheEntry]] = {}
+        for entry in entries:
+            by_class.setdefault(entry.class_name, []).append(entry)
+        
+        lines = [
+            '"""Generated code exported from scry-run cache."""',
+            "",
+        ]
+        
+        # Add imports
+        if all_deps:
+            for dep in sorted(all_deps):
+                lines.append(dep)
+            lines.append("")
+        
+        # Add code for each class
+        for class_name, class_entries in sorted(by_class.items()):
+            lines.append(f"# === {class_name} ===")
+            lines.append("")
+            
+            for entry in sorted(class_entries, key=lambda e: e.attr_name):
+                if entry.docstring:
+                    lines.append(f"# {entry.docstring}")
+                lines.append(f"# Type: {entry.code_type}")
+                lines.append(entry.code)
+                lines.append("")
+        
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines))

scry_run/cli/__init__.py

@@ -0,0 +1,137 @@
+"""CLI entry point for scry-run."""
+
+import sys
+import click
+from rich.console import Console
+from typing import Optional
+
+from scry_run.cli.init import init
+
+console = Console()
+from scry_run.cli.cache import cache
+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.generator import CodeGenerator, ScryRunError
+
+
+class DefaultGroup(click.Group):
+    """Click Group that invokes a default command for unknown commands."""
+    
+    def __init__(self, *args, **kwargs):
+        # To support default command, we need to allow resolving unknown commands
+        # to the default handler
+        self.default_cmd_name = kwargs.pop("default_if_missing", None)
+        super().__init__(*args, **kwargs)
+
+    def resolve_command(self, ctx, args):
+        try:
+            # Try to resolve the command normally
+            return super().resolve_command(ctx, args)
+        except click.UsageError as e:
+            # If command not found and we have a default...
+            if self.default_cmd_name:
+                # check if the command actually exists in our list (to be safe)
+                cmd = self.get_command(ctx, self.default_cmd_name)
+                if cmd:
+                    # If we are falling back to default, we treat ALL args
+                    # as arguments to the default command.
+                    # This is tricky because Click removed the command name from args
+                    # if it thought it was a command but failed.
+                    # But here, 'args' passed to resolve_command are the remaining args.
+                    
+                    # If the first arg was what Click thought was a command name,
+                    # we need to put it back into the args list for the default command
+                    # if we want the default command to see it.
+                    # actually resolve_command returns (cmd_name, cmd, args)
+                    # The 'args' passed IN are the ones to be processed.
+                    
+                    # We just return the default command and the full args.
+                    return self.default_cmd_name, cmd, args
+            
+            # If no default or other error, raise original
+            raise
+
+
+@click.group(cls=DefaultGroup, default_if_missing="ask", context_settings={"ignore_unknown_options": True})
+@click.version_option()
+def main() -> None:
+    """scry-run: LLM-powered dynamic code generation.
+    
+    Use a metaclass to automatically generate missing code via LLMs.
+    """
+    pass
+
+
+@main.command(hidden=True, context_settings={"ignore_unknown_options": True})
+@click.argument("prompt_parts", nargs=-1)
+def ask(prompt_parts: tuple[str, ...]) -> None:
+    """Default command: Ask the coding assistant."""
+    # Collect all parts including unknown options causing confusion
+    ctx = click.get_current_context()
+    
+    # If ignore_unknown_options=True, unparsed options are in ctx.args (as a list)
+    # prompt_parts contains the positional arguments
+    
+    # We need to reconstruct the order if possible, or just append.
+    # Typically ctx.args contains options that were skipped.
+    # But since we want "everything as string", order matters slightly but appending is likely safe enough for natural language.
+    # However, for perfect reconstruction, we might look at sys.argv keywords? NO.
+    
+    # Let's combine them. prompt_parts are the recognized parts (non-options).
+    # ctx.args are the ignored options.
+    # Wait, Click splits them.
+    # If user types: scry-run --flag word
+    # --flag goes to ctx.args (if ignored), word goes to prompt_parts.
+    
+    parent_args = ctx.parent.args if ctx.parent else []
+    current_args = ctx.args
+    
+    full_parts = list(parent_args) + list(prompt_parts) + list(current_args)
+    
+    if not full_parts:
+        # If no arguments, show help
+        # Note: ctx.parent.get_help() returns the help string for the group (main)
+        click.echo(ctx.parent.get_help())
+        ctx.exit(0)
+    
+    # Simple join might be messy if flags were interspersed. 
+    # But "write a poem -f json" -> "write a poem" + "-f" + "json"?
+    # Click might parse "-f" as option, "json" as argument.
+    # prompt_parts=["write", "a", "poem", "json"], ctx.args=["-f"]
+    # So "write a poem json -f". Acceptable for LLM prompt usually.
+    
+    prompt = " ".join(full_parts)
+    
+    try:
+        generator = CodeGenerator()
+        response = generator.generate_freeform(prompt)
+        console.print(response)
+
+    except ScryRunError as e:
+        console.print(f"[red]Error:[/red] {e.message}", highlight=False)
+        if e.hint:
+            console.print(f"[dim]Hint:[/dim] {e.hint}", highlight=False)
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", highlight=False)
+        sys.exit(1)
+
+
+# Register commands
+main.add_command(init)
+main.add_command(init, name="new")  # Alias
+main.add_command(cache)
+main.add_command(run)
+main.add_command(env)
+main.add_command(list_apps, name="list")
+main.add_command(which_app, name="which")
+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")
+
+
+if __name__ == "__main__":
+    main()