wishful 0.2.1__py3-none-any.whl

wishful/core/discovery.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import ast
+import inspect
+import linecache
+import os
+from pathlib import Path
+from textwrap import dedent
+from typing import Iterable, List, Sequence
+
+from wishful.types import get_all_type_schemas, get_output_type_for_function
+
+# Default radius for surrounding-context capture; configurable via env + setter.
+_context_radius = int(os.getenv("WISHFUL_CONTEXT_RADIUS", "3"))
+
+
+class ImportContext:
+    def __init__(
+        self,
+        functions: Sequence[str],
+        context: str | None,
+        type_schemas: dict[str, str] | None = None,
+        function_output_types: dict[str, str] | None = None,
+    ):
+        self.functions = list(functions)
+        self.context = context
+        self.type_schemas = type_schemas or {}
+        self.function_output_types = function_output_types or {}
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return (
+            f"ImportContext(functions={self.functions}, "
+            f"context={self.context!r}, "
+            f"type_schemas={list(self.type_schemas.keys())}, "
+            f"function_output_types={self.function_output_types})"
+        )
+
+
+def _gather_context_lines(filename: str, lineno: int, radius: int = 2) -> str:
+    lines = linecache.getlines(filename)
+    if not lines:
+        return ""
+    start = max(lineno - radius, 1) - 1
+    end = min(lineno + radius, len(lines))
+    snippet = lines[start:end]
+    return "".join(snippet).strip()
+
+
+def _parse_imported_names(source_line: str, fullname: str) -> List[str]:
+    tree = _safe_parse_line(source_line)
+    if tree is None:
+        return []
+
+    names: list[str] = []
+    names.extend(_names_from_import_from(tree, fullname))
+    names.extend(_names_from_import(tree, fullname))
+    return names
+
+
+def _safe_parse_line(source_line: str) -> ast.AST | None:
+    try:
+        return ast.parse(dedent(source_line))
+    except SyntaxError:
+        return None
+
+
+def _names_from_import_from(tree: ast.AST, fullname: str) -> list[str]:
+    return [
+        alias.name
+        for node in ast.walk(tree)
+        if isinstance(node, ast.ImportFrom)
+        for alias in node.names
+        if _matches_import_from(node.module, fullname)
+    ]
+
+
+def _names_from_import(tree: ast.AST, fullname: str) -> list[str]:
+    matches: list[str] = []
+    for node in (n for n in ast.walk(tree) if isinstance(n, ast.Import)):
+        matches.extend(_alias_targets(node.names, fullname))
+    return matches
+
+
+def _alias_targets(aliases: Sequence[ast.alias], fullname: str) -> list[str]:
+    return [
+        alias.asname or alias.name.split(".")[-1]
+        for alias in aliases
+        if _matches_import(alias.name, fullname)
+    ]
+
+
+def _is_plain_import(fullname: str, tree: ast.AST) -> bool:
+    """Return True when the line is an ast.Import of the fullname (not ImportFrom)."""
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if _matches_import(alias.name, fullname):
+                    return True
+    return False
+
+
+def _matches_import_from(module: str | None, fullname: str) -> bool:
+    return bool(module) and module.startswith("wishful") and fullname.startswith(module)
+
+
+def _matches_import(name: str, fullname: str) -> bool:
+    return name.startswith("wishful") and fullname.startswith(name)
+
+
+def discover(fullname: str, runtime_context: dict | None = None) -> ImportContext:
+    """Attempt to recover requested symbol names and nearby comments.
+
+    `runtime_context` is an optional dict (e.g., function name/args) that will
+    be appended to the textual context sent to the LLM for dynamic calls.
+    """
+
+    first_frame: tuple[str, int] | None = None
+
+    for filename, lineno in _iter_relevant_frames(fullname):
+        if first_frame is None:
+            first_frame = (filename, lineno)
+        code_line = linecache.getline(filename, lineno).strip()
+        if not code_line:
+            continue
+
+        functions = _parse_imported_names(code_line, fullname)
+        if not functions:
+            continue
+
+        tree = _safe_parse_line(code_line)
+        if tree and _is_plain_import(fullname, tree):
+            functions = []
+
+        context = _build_context_snippets(filename, lineno, functions)
+
+        if runtime_context:
+            context = _append_runtime_context(context, runtime_context)
+
+        # Fetch type information from registry
+        type_schemas = get_all_type_schemas()
+        function_output_types = {}
+        for func in functions:
+            output_type = get_output_type_for_function(func)
+            if output_type:
+                function_output_types[func] = output_type
+        
+        return ImportContext(
+            functions=functions,
+            context=context,
+            type_schemas=type_schemas,
+            function_output_types=function_output_types,
+        )
+
+    # Fallback: even if we couldn't parse requested symbols (e.g., module-level
+    # imports with later attribute access), still capture nearby context so the
+    # LLM gets some hints.
+    if first_frame is not None:
+        filename, lineno = first_frame
+        context = _build_context_snippets(filename, lineno, [])
+    else:
+        context = None
+
+    if runtime_context:
+        context = _append_runtime_context(context, runtime_context)
+
+    type_schemas = get_all_type_schemas()
+    return ImportContext(functions=[], context=context, type_schemas=type_schemas)
+
+
+def _append_runtime_context(context: str | None, runtime_context: dict) -> str:
+    def _safe(val):
+        text = repr(val)
+        return text[:500] + "…" if len(text) > 500 else text
+
+    parts = ["Runtime call context:"]
+    for key, val in runtime_context.items():
+        parts.append(f"- {key}: {_safe(val)}")
+
+    runtime_block = "\n".join(parts)
+    if context:
+        return f"{context}\n\n{runtime_block}"
+    return runtime_block
+
+
+def _iter_relevant_frames(fullname: str) -> Iterable[tuple[str, int]]:
+    frame = inspect.currentframe()
+    if frame:
+        frame = frame.f_back
+
+    while frame:
+        filename = frame.f_code.co_filename
+        lineno = frame.f_lineno
+
+        if _is_user_frame(filename):
+            yield filename, lineno
+
+        frame = frame.f_back
+
+
+def _is_user_frame(filename: str) -> bool:
+    if filename.startswith("<"):
+        return False
+    normalized = filename.replace("\\", "/")
+    return not ("/src/wishful/" in normalized and "/tests/" not in normalized)
+
+
+def _gather_usage_context(filename: str, functions: Sequence[str], radius: int) -> list[str]:
+    """Collect context snippets around call sites of the requested functions."""
+    if not functions:
+        return []
+
+    tree = _parse_file_safe(filename)
+    if tree is None:
+        return []
+
+    linenos = _call_site_lines(tree, set(functions))
+    return _snippets_from_lines(filename, linenos, radius)
+
+
+def _call_site_lines(tree: ast.AST, targets: set[str]) -> list[int]:
+    return [
+        node.lineno
+        for node in ast.walk(tree)
+        if isinstance(node, ast.Call)
+        if isinstance(node.func, ast.Name)
+        if node.func.id in targets
+    ]
+
+
+def _snippets_from_lines(filename: str, linenos: Sequence[int], radius: int) -> list[str]:
+    snippets = [_gather_context_lines(filename, lineno, radius=radius) for lineno in linenos]
+    return _dedupe([s for s in snippets if s])
+
+
+def _parse_file_safe(filename: str) -> ast.AST | None:
+    try:
+        return ast.parse(Path(filename).read_text())
+    except (OSError, SyntaxError):
+        return None
+
+
+def _build_context_snippets(filename: str, lineno: int, functions: Sequence[str]) -> str | None:
+    snippets = [_gather_context_lines(filename, lineno, radius=_context_radius)]
+    snippets += _gather_usage_context(filename, functions, radius=_context_radius)
+    combined = "\n\n".join(part for part in snippets if part)
+    return combined or None
+
+
+def _dedupe(items: Sequence[str]) -> list[str]:
+    seen = set()
+    unique: list[str] = []
+    for item in items:
+        if item not in seen:
+            seen.add(item)
+            unique.append(item)
+    return unique
+
+
+def set_context_radius(radius: int) -> None:
+    """Update the global context radius used for import discovery."""
+    global _context_radius
+    if radius < 0:
+        raise ValueError("context radius must be non-negative")
+    _context_radius = radius

wishful/core/finder.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import importlib.abc
+import importlib.util
+import sys
+from pathlib import Path
+
+from wishful.core.loader import MagicLoader, MagicPackageLoader
+
+
+MAGIC_NAMESPACE = "wishful"
+STATIC_NAMESPACE = "wishful.static"
+DYNAMIC_NAMESPACE = "wishful.dynamic"
+
+
+class MagicFinder(importlib.abc.MetaPathFinder):
+    """Intercept imports for the `wishful.static.*` and `wishful.dynamic.*` namespaces."""
+
+    def find_spec(self, fullname: str, path, target=None):  # type: ignore[override]
+        if not fullname.startswith(MAGIC_NAMESPACE):
+            return None
+
+        # Allow internal wishful modules (core, cache, llm, etc.)
+        if _is_internal_module(fullname):
+            return None
+
+        # Handle root namespace packages
+        if fullname == MAGIC_NAMESPACE:
+            # Let the real installed package handle the root 'wishful'
+            return None
+        if fullname == STATIC_NAMESPACE:
+            return importlib.util.spec_from_loader(fullname, MagicPackageLoader(), is_package=True)
+        if fullname == DYNAMIC_NAMESPACE:
+            return importlib.util.spec_from_loader(fullname, MagicPackageLoader(), is_package=True)
+
+        # Determine if this is a static or dynamic import
+        is_static = fullname.startswith(STATIC_NAMESPACE + ".")
+        is_dynamic = fullname.startswith(DYNAMIC_NAMESPACE + ".")
+
+        if is_static:
+            return importlib.util.spec_from_loader(
+                fullname, MagicLoader(fullname, mode="static"), is_package=False
+            )
+        elif is_dynamic:
+            return importlib.util.spec_from_loader(
+                fullname, MagicLoader(fullname, mode="dynamic"), is_package=False
+            )
+
+        # Reject direct wishful.* imports that aren't static/dynamic
+        return None
+
+
+def _is_internal_module(fullname: str) -> bool:
+    """Check if a module is part of the internal wishful package."""
+    parts = fullname.split('.')
+    if len(parts) < 2:
+        return False
+    
+    # Skip static/dynamic namespace checks - they're never internal
+    if parts[1] in ('static', 'dynamic'):
+        return False
+    
+    # Check if it's a real internal module
+    module_file = Path(__file__).parent.parent / parts[1]
+    return module_file.exists() or module_file.with_suffix('.py').exists()
+
+
+def install() -> None:
+    """Register the finder if it is not already present."""
+
+    for finder in sys.meta_path:
+        if finder.__class__.__name__ == "MagicFinder" and finder.__class__.__module__.endswith(
+            "wishful.core.finder"
+        ):
+            return
+
+    sys.meta_path.insert(0, MagicFinder())

wishful/core/loader.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import importlib
+import importlib.abc
+import importlib.util
+import sys
+from types import ModuleType
+
+from wishful.cache import manager as cache
+from wishful.config import settings
+from wishful.core.discovery import discover
+from wishful.llm.client import GenerationError, generate_module_code
+from wishful.logging import logger
+from wishful.safety.validator import SecurityError, validate_code
+from wishful.ui import spinner
+
+def _resolve_generate_module_code():
+    """Use the generate_module_code function from the live loader module.
+
+    MagicLoader instances can outlive module reloads during tests; looking up
+    the function each time keeps monkeypatches effective while preferring any
+    patched version over the original default.
+    """
+    default_fn = importlib.import_module("wishful.llm.client").generate_module_code
+
+    mod = sys.modules.get(__name__)
+    candidates = []
+    if mod is not None and hasattr(mod, "generate_module_code"):
+        candidates.append(getattr(mod, "generate_module_code"))
+    # Always consider the function bound in this module too
+    candidates.append(generate_module_code)
+
+    for fn in candidates:
+        if fn is not default_fn:
+            return fn
+    return default_fn
+
+
+class DynamicProxyModule(ModuleType):
+    """Module proxy that regenerates the underlying module on each attribute access."""
+
+    _SAFE_ATTRS = {
+        "__class__",
+        "__dict__",
+        "__doc__",
+        "__loader__",
+        "__name__",
+        "__package__",
+        "__path__",
+        "__spec__",
+        "__file__",
+        "__builtins__",
+        "_wishful_loader",
+    }
+
+    def __getattribute__(self, name):
+        if name.startswith("__") or name in DynamicProxyModule._SAFE_ATTRS:
+            return super().__getattribute__(name)
+
+        loader = super().__getattribute__("_wishful_loader")
+        loader._regenerate_for_proxy(self, name)
+
+        attr = super().__getattribute__(name)
+
+        if callable(attr):
+            def _wrapped(*args, **kwargs):
+                return loader._call_with_runtime(self, name, args, kwargs)
+
+            _wrapped.__name__ = name
+            _wrapped.__doc__ = getattr(attr, "__doc__", None)
+            return _wrapped
+
+        return attr
+
+
+class MagicLoader(importlib.abc.Loader):
+    """Loader that returns dynamic modules backed by cache + LLM generation.
+    
+    Supports two modes:
+    - 'static': Traditional cached behavior (default)
+    - 'dynamic': Regenerates with runtime context on every access
+    """
+
+    def __init__(self, fullname: str, mode: str = "static"):
+        self.fullname = fullname
+        self.mode = mode  # 'static' or 'dynamic'
+
+    def create_module(self, spec):  # pragma: no cover - default works
+        return None
+
+    def exec_module(self, module: ModuleType) -> None:
+        context = discover(self.fullname)
+        source, from_cache, file_path = self._load_source(context)
+
+        logger.debug(
+            "exec_module fullname={} mode={} from_cache={} file={} functions={}",
+            self.fullname,
+            self.mode,
+            from_cache,
+            file_path,
+            context.functions,
+        )
+
+        if self.mode == "dynamic":
+            self._attach_dynamic_proxy(module)
+
+        self._exec_source(source, module, context, file_path=file_path)
+        self._ensure_symbols(module, context, from_cache)
+        if self.mode == "dynamic":
+            self._maybe_review(source)
+            return
+
+        self._attach_dynamic_getattr(module)
+        self._maybe_review(source)
+
+    def _generate_and_cache(self, functions, context):
+        logger.info("Generating {}", self.fullname)
+        logger.debug(
+            "generate start fullname={} mode={} functions={}", self.fullname, self.mode, functions
+        )
+        with spinner(f"Generating {self.fullname}"):
+            gen_fn = _resolve_generate_module_code()
+            source = gen_fn(
+                self.fullname,
+                functions,
+                context.context,
+                type_schemas=context.type_schemas,
+                function_output_types=context.function_output_types,
+                mode=self.mode,
+            )
+        if self.mode == "static":
+            path = cache.write_cached(self.fullname, source)
+        else:
+            path = cache.write_dynamic_snapshot(self.fullname, source)
+        logger.debug("generate done fullname={} path={}", self.fullname, path)
+        return source, path
+
+    def _exec_source(
+        self,
+        source: str,
+        module: ModuleType,
+        context,
+        clear_first: bool = False,
+        file_path: str | None = None,
+        allow_retry: bool = True,
+    ) -> None:
+        try:
+            validate_code(source, allow_unsafe=settings.allow_unsafe)
+            preserved_loader = module.__dict__.get("_wishful_loader")
+            if clear_first:
+                module.__dict__.clear()
+                if preserved_loader is not None:
+                    module.__dict__["_wishful_loader"] = preserved_loader
+            module.__file__ = file_path or str(cache.module_path(self.fullname))
+            module.__package__ = self.fullname.rpartition('.')[0]
+            exec(compile(source, module.__file__, "exec"), module.__dict__)
+        except SyntaxError:
+            logger.warning("SyntaxError while loading {}; retrying once", self.fullname)
+            if not allow_retry:
+                raise
+            # Regenerate once on syntax errors
+            if self.mode == "static":
+                cache.delete_cached(self.fullname)
+            source2, path2 = self._generate_and_cache(context.functions, context)
+            self._exec_source(
+                source2,
+                module,
+                context,
+                clear_first=True,
+                file_path=str(path2),
+                allow_retry=False,
+            )
+
+    def _attach_dynamic_getattr(self, module: ModuleType) -> None:
+        def _dynamic_getattr(name: str):
+            if name.startswith("__"):
+                raise AttributeError(name)
+
+            ctx = discover(self.fullname)
+            functions = set(ctx.functions or [])
+            declared = self._declared_symbols(module)
+            desired = sorted(declared | functions | {name})
+
+            source, path = self._generate_and_cache(desired, ctx)
+            self._exec_source(source, module, ctx, clear_first=True, file_path=str(path))
+            # Re-attach for future misses after reload
+            setattr(module, "__getattr__", _dynamic_getattr)  # type: ignore[assignment]
+            if name in module.__dict__:
+                return module.__dict__[name]
+            raise AttributeError(name)
+
+        setattr(module, "__getattr__", _dynamic_getattr)  # type: ignore[assignment]
+
+    def _attach_dynamic_proxy(self, module: ModuleType) -> None:
+        if not isinstance(module, DynamicProxyModule):
+            module.__class__ = DynamicProxyModule  # type: ignore[misc]
+        setattr(module, "_wishful_loader", self)
+
+    @staticmethod
+    def _declared_symbols(module: ModuleType) -> set[str]:
+        return {
+            k
+            for k in module.__dict__
+            if not k.startswith("__") and not k.startswith("_wishful_")
+        }
+
+    def _load_source(self, context) -> tuple[str, bool, str]:
+        # Dynamic mode: always regenerate, never use cache
+        if self.mode == "dynamic":
+            source, path = self._generate_and_cache(context.functions, context)
+            return source, False, str(path)
+
+        # Static mode: use cache if available
+        source = cache.read_cached(self.fullname)
+        if source is not None:
+            logger.debug("cache hit fullname={}", self.fullname)
+            return source, True, str(cache.module_path(self.fullname))
+        logger.debug("cache miss fullname={}", self.fullname)
+        source, path = self._generate_and_cache(context.functions, context)
+        return source, False, str(path)
+
+    def _ensure_symbols(self, module: ModuleType, context, from_cache: bool) -> None:
+        if not context.functions:
+            return
+
+        missing = self._missing_symbols(module, context.functions)
+        if not missing:
+            return
+
+        if not from_cache:
+            raise GenerationError(
+                f"Generated module for {self.fullname} lacks symbols: {', '.join(missing)}"
+            )
+
+        self._regenerate_with(module, context)
+
+    def _maybe_review(self, source: str) -> None:
+        if not settings.review:
+            return
+        print(f"Generated code for {self.fullname}:\n{source}\n")
+        answer = input("Run this code? [y/N]: ")
+        if answer.lower().strip() not in {"y", "yes"}:
+            cache.delete_cached(self.fullname)
+            raise ImportError("User rejected generated code.")
+
+    def _missing_symbols(self, module: ModuleType, requested: list[str]) -> list[str]:
+        return [name for name in requested if name not in module.__dict__]
+
+    def _regenerate_with(self, module: ModuleType, context) -> None:
+        desired = sorted(set(context.functions) | self._declared_symbols(module))
+        cache.delete_cached(self.fullname)
+        source, path = self._generate_and_cache(desired, context)
+        self._exec_source(source, module, context, clear_first=True, file_path=str(path))
+
+    def _regenerate_for_proxy(self, module: ModuleType, requested: str) -> None:
+        ctx = discover(self.fullname)
+        desired = set(ctx.functions or []) | {requested} | self._declared_symbols(module)
+        ctx.functions = sorted(desired)
+        source, path = self._generate_and_cache(ctx.functions, ctx)
+        self._exec_source(source, module, ctx, clear_first=True, file_path=str(path))
+
+    def _call_with_runtime(self, module: ModuleType, func_name: str, args, kwargs):
+        ctx = discover(self.fullname, runtime_context={"function": func_name, "args": args, "kwargs": kwargs})
+        desired = set(ctx.functions or []) | {func_name} | self._declared_symbols(module)
+        ctx.functions = sorted(desired)
+
+        source, path = self._generate_and_cache(ctx.functions, ctx)
+        self._exec_source(source, module, ctx, clear_first=True, file_path=str(path))
+
+        target = module.__dict__.get(func_name)
+        if callable(target):
+            return target(*args, **kwargs)
+        raise AttributeError(func_name)
+
+
+class MagicPackageLoader(importlib.abc.Loader):
+    """Loader for the root 'wishful' package to enable namespace imports."""
+
+    def create_module(self, spec):  # pragma: no cover - default create
+        return None
+
+    def exec_module(self, module: ModuleType) -> None:
+        module.__path__ = [str(cache.ensure_cache_dir())]
+        module.__package__ = "wishful"
+        module.__file__ = str(cache.ensure_cache_dir() / "__init__.py")

wishful/dynamic/__init__.py

@@ -0,0 +1,8 @@
+"""Wishful dynamic namespace - runtime-context-aware code generation.
+
+Modules imported from wishful.dynamic.* are regenerated on every import,
+capturing runtime context and values for context-sensitive code generation.
+
+Example:
+    from wishful.dynamic.stories import create_opening
+"""

wishful/dynamic/__init__.pyi

@@ -0,0 +1,7 @@
+"""Type stub for wishful.dynamic namespace.
+
+This stub helps IDEs and type checkers understand that wishful.dynamic.*
+is a valid namespace for dynamically generated modules.
+"""
+
+def __getattr__(name: str) -> object: ...

wishful/llm/__init__.py

@@ -0,0 +1,5 @@
+"""LLM integration layer."""
+
+from .client import generate_module_code, GenerationError
+
+__all__ = ["generate_module_code", "GenerationError"]