vybthon 0.1.0__py3-none-any.whl

vibe/__init__.py

@@ -0,0 +1,16 @@
+"""vibe: objects whose methods are written by an LLM the moment you call them
+
+    >>> from vibe import Vibe
+    >>> v = Vibe()
+    >>> v.reverse_string("hello")      
+    'olleh'
+    >>> v.nth_prime(10)               
+    29
+
+vibed code is executed with minimal checks. LLM output is untrusted.
+"""
+
+from .codegen import VibeError
+from .core import Vibe
+
+__all__ = ["Vibe", "VibeError"]

vibe/codegen.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Callable
+
+_FENCE_RE = re.compile(r"```(?:[a-zA-Z0-9_+-]*)?\s*\n(.*?)```", re.DOTALL)
+
+# How much of each argument to show the model: enough to convey shape and
+# element types without flooding the prompt with large inputs.
+_SAMPLE = 3       # elements shown from a collection argument
+_MAX_REPR = 200   # characters shown from a single value's repr
+
+SYSTEM_PROMPT = """\
+You are a Python function synthesizer. Given a function name and the exact \
+arguments it will be called with, you write exactly one Python function \
+implementing the behavior implied by the name.
+
+Hard rules:
+- Output ONLY the function definition. No prose, no markdown fences, no usage \
+examples, no test calls, no print statements.
+- The function MUST be named exactly `{name}`.
+- The function MUST be callable exactly as the call shown below. Every parameter \
+the call does not supply MUST have a default value, so that call succeeds. Extra \
+optional parameters are fine; an extra *required* parameter is not. Add precise \
+type hints.
+- Add one concise docstring line.
+- Use ONLY the Python standard library. Third-party packages (e.g. \
+`phonenumbers`, `numpy`, `requests`) are NOT installed and importing them fails \
+at runtime — implement the behavior yourself instead. Put any `import` \
+statements INSIDE the function body.
+- Be pure and deterministic: no I/O, no network, no global state, and no \
+randomness unless the name explicitly implies it.
+- Return the result; never just print it.\
+"""
+
+USER_PROMPT = """\
+Write the function `{name}`.
+
+It will be called like:
+    {call}
+
+Arguments:
+{arguments}
+
+Define `{name}` so this exact call works, then infer the intended behavior from \
+the name and the inputs and return the function definition.\
+"""
+
+RETRY_PROMPT = """\
+
+The previous version of `{name}` failed when called with these arguments:
+    {error}
+
+Write a corrected version that does not raise this error.{hint}\
+"""
+
+# Extra, error-specific guidance appended to the retry prompt.
+IMPORT_HINT = (
+    " That module is NOT installed and never will be — do not reach for another "
+    "third-party package. Implement this using ONLY the Python standard library."
+)
+
+
+class VibeError(RuntimeError):
+    """Raised when synthesis produces something we can't turn into a function.
+
+    Carries the offending source; ``str(err)`` appends it with line numbers.
+    """
+
+    def __init__(
+        self, message: str, *, name: str | None = None, source: str | None = None
+    ) -> None:
+        super().__init__(message)
+        self.name = name
+        self.source = source
+
+    def __str__(self) -> str:
+        base = super().__str__()
+        if not self.source:
+            return base
+        width = len(str(self.source.count("\n") + 1))
+        numbered = "\n".join(
+            f"  {i:>{width}} | {line}"
+            for i, line in enumerate(self.source.splitlines(), 1)
+        )
+        label = f" for {self.name!r}" if self.name else ""
+        return f"{base}\n\n  synthesized source{label}:\n{numbered}"
+
+
+def strip_fences(text: str) -> str:
+    """Pull code out of a ```fenced``` block if present, else return as-is."""
+    match = _FENCE_RE.search(text)
+    return (match.group(1) if match else text).strip()
+
+
+def _preview(value: Any) -> str:
+    """A bounded repr of ``value``: collections sampled, long values truncated."""
+    if isinstance(value, (list, tuple, set, frozenset)):
+        items = list(value)
+        shown = ", ".join(repr(x) for x in items[:_SAMPLE])
+        more = f", … (+{len(items) - _SAMPLE} more)" if len(items) > _SAMPLE else ""
+        brackets = {list: "[]", tuple: "()", set: "{}", frozenset: "{}"}[type(value)]
+        return f"{brackets[0]}{shown}{more}{brackets[1]}"
+    if isinstance(value, dict):
+        items = list(value.items())
+        shown = ", ".join(f"{k!r}: {v!r}" for k, v in items[:_SAMPLE])
+        more = f", … (+{len(items) - _SAMPLE} more)" if len(items) > _SAMPLE else ""
+        return f"{{{shown}{more}}}"
+    text = repr(value)
+    if len(text) > _MAX_REPR:
+        return f"{text[:_MAX_REPR]}… (+{len(text) - _MAX_REPR} chars)"
+    return text
+
+
+def render_call(name: str, args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
+    """Render the call expression, e.g. ``greet('Sam', loud=True)`` (values bounded)."""
+    parts = [_preview(a) for a in args]
+    parts += [f"{k}={_preview(v)}" for k, v in kwargs.items()]
+    return f"{name}({', '.join(parts)})"
+
+
+def render_arguments(args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
+    """One line per argument: position/name, type, and a bounded value preview."""
+    lines = [
+        f"  - positional #{i}: type {type(a).__name__}, value {_preview(a)}"
+        for i, a in enumerate(args, 1)
+    ]
+    lines += [
+        f"  - keyword {k!r}: type {type(v).__name__}, value {_preview(v)}"
+        for k, v in kwargs.items()
+    ]
+    return "\n".join(lines) if lines else "  (none)"
+
+
+def build_messages(
+    name: str,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    error: Exception | None = None,
+) -> list[dict[str, str]]:
+    """Build the chat messages that ask the model to synthesize ``name``.
+
+    If ``error`` is given (a previous attempt that raised), its type and message
+    are appended so the model can correct course on the retry.
+    """
+    user = USER_PROMPT.format(
+        name=name,
+        call=render_call(name, args, kwargs),
+        arguments=render_arguments(args, kwargs),
+    )
+    if error is not None:
+        hint = IMPORT_HINT if isinstance(error, ImportError) else ""
+        user += RETRY_PROMPT.format(
+            name=name, error=f"{type(error).__name__}: {error}", hint=hint
+        )
+    return [
+        {"role": "system", "content": SYSTEM_PROMPT.format(name=name)},
+        {"role": "user", "content": user},
+    ]
+
+
+def materialize(source: str, name: str) -> Callable[..., Any]:
+    """exec ``source`` in a fresh namespace and pull out the function ``name``."""
+    namespace: dict[str, Any] = {}
+    try:
+        exec(compile(source, f"<vibe:{name}>", "exec"), namespace)
+    except SyntaxError as exc:
+        raise VibeError(
+            f"synthesized code for {name!r} is not valid Python: {exc}",
+            name=name,
+            source=source,
+        ) from exc
+    fn = namespace.get(name)
+    if not callable(fn):
+        raise VibeError(
+            f"synthesized code did not define a callable named {name!r}; "
+            f"got {type(fn).__name__}",
+            name=name,
+            source=source,
+        )
+    return fn

vibe/console.py

@@ -0,0 +1,22 @@
+"""Minimal status output for synthesis. Colour is used only on a TTY."""
+
+from __future__ import annotations
+
+import sys
+
+_DIM = "\033[2m"
+_RESET = "\033[0m"
+
+
+class Console:
+    def __init__(self, *, enabled: bool = False) -> None:
+        self._on = enabled
+        self._color = enabled and sys.stderr.isatty()
+
+    def status(self, message: str) -> None:
+        """A dim, prefixed status line, e.g. ``vibe  synthesizing reverse_string``."""
+        if not self._on:
+            return
+        line = f"vibe  {message}"
+        sys.stderr.write(f"{_DIM}{line}{_RESET}\n" if self._color else f"{line}\n")
+        sys.stderr.flush()

vibe/core.py

@@ -0,0 +1,200 @@
+"""The ``Vibe`` object: undefined methods are synthesized by an LLM on call."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Callable
+
+import litellm
+from litellm import CustomStreamWrapper, completion
+from litellm.types.utils import ModelResponseStream, StreamingChoices
+
+from .codegen import build_messages, materialize, strip_fences
+from .console import Console
+
+litellm.suppress_debug_info = True  # silence litellm's "Provider List" banner
+
+
+
+class Vibe:
+    """An object whose undefined methods are synthesized by an LLM on first call.
+
+    Call any method name; if it doesn't exist yet, the model writes a function
+    that does what the name + arguments imply, it's executed, and the source is
+    cached to disk for reuse on later calls and future runs.
+
+    SECURITY: synthesized code is executed with ``exec``. LLM output is
+    untrusted — treat every generated function as arbitrary code. This is a toy,
+    not a sandbox; run it only against a local model you trust.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        *,
+        api_base: str | None ,
+        api_key: str | None = None,
+        extra_body: dict[str, Any] | None = None,
+        cache_dir: Path | str | None = None,
+        verbose: bool = False,
+        retries: int = 2,
+        caching: bool = True,
+    ) -> None:
+        self._model = model
+        self._api_base = api_base
+        self._api_key = api_key
+        self._extra_body = extra_body
+        self._cache_dir = Path(cache_dir) if cache_dir else Path.cwd() / ".vibe_cache"
+        self._retries = retries
+        self._console = Console(enabled=verbose)
+        self._fns: dict[str, Callable[..., Any]] = {}
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+        self._caching = caching
+
+    @classmethod
+    def openrouter(
+        cls,
+        model: str,
+        *,
+        reasoning: bool = False,
+        **kwargs: Any,
+    ) -> "Vibe":
+        OPENROUTER_BASE_URL = os.getenv("OPENROUTER_API_BASE", "https://openrouter.ai/api/v1")
+        OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY")
+
+        if reasoning:
+            extra_body = {**kwargs.pop("extra_body", {}), "reasoning": {"enabled": True}}
+            kwargs["extra_body"] = extra_body
+        return cls(model, api_base=OPENROUTER_BASE_URL, api_key=OPENROUTER_API_KEY, **kwargs)
+
+    # -- public surface ----------------------------------------------------
+
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        # Never intercept dunder / private lookups (copy, repr, IPython probes,
+        # and our own ``self._foo`` access during __init__ all rely on this).
+        if name.startswith("_"):
+            raise AttributeError(name)
+
+        def caller(*args: Any, **kwargs: Any) -> Any:
+            return self._call(name, args, kwargs)
+
+        caller.__name__ = name
+        caller.__qualname__ = f"Vibe.{name}"
+        return caller
+
+    # -- call / retry ------------------------------------------------------
+
+    def _call(
+        self, name: str, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> Any:
+        """Resolve and invoke ``name``. If synthesis or the call itself fails,
+        evict the bad version and re-synthesize with the exception as context,
+        up to ``self._retries`` times."""
+        error: Exception | None = None
+        for attempt in range(1, self._retries + 2):  # 1 initial try + N retries
+            try:
+                fn = self._resolve(name, args, kwargs, error)
+                return fn(*args, **kwargs)
+            except Exception as exc:
+                self._evict(name)  # this version is bad — don't keep or reuse it
+                error = exc
+                self._console.status(f"{name} failed (attempt {attempt}): {exc!r}")
+        assert error is not None
+        raise error
+
+    def _evict(self, name: str) -> None:
+        """Drop a synthesized function from both caches so it is regenerated."""
+        self._fns.pop(name, None)
+        self._cache_path(name).unlink(missing_ok=True)
+
+    # -- resolution / caching ---------------------------------------------
+
+    def _resolve(
+        self,
+        name: str,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        error: Exception | None = None,
+    ) -> Callable[..., Any]:
+        """Return a callable for ``name``: memory cache → disk cache → synthesize.
+
+        On a retry (``error`` set) the caches are skipped and a fresh version is
+        synthesized with the failure as context.
+        """
+        if self._caching and error is None:
+            cached = self._fns.get(name)
+            if cached is not None:
+                return cached
+
+            path = self._cache_path(name)
+            if path.exists():
+                fn = materialize(path.read_text(), name)
+                self._fns[name] = fn
+                return fn
+
+        source = strip_fences(self._generate(name, args, kwargs, error))
+        fn = materialize(source, name)
+        if self._caching:
+            self._cache_path(name).write_text(self._cache_header(name) + source + "\n")
+            self._fns[name] = fn
+        return fn
+
+    def _cache_path(self, name: str) -> Path:
+        return self._cache_dir / f"{name}.py"
+
+    def _cache_header(self, name: str) -> str:
+        return (
+            f"# vibe-generated: {name}\n"
+            f"# model: {self._model}\n"
+            f"# WARNING: machine-written code, review before trusting.\n\n"
+        )
+
+    # -- generation --------------------------------------------------------
+
+    def _generate(
+        self,
+        name: str,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        error: Exception | None = None,
+    ) -> str:
+        """Synthesize the source for ``name`` (one request; ``_call`` handles retries).
+
+        When ``error`` is set, it is passed to the model as context so the new
+        version avoids whatever the previous one got wrong.
+        """
+        self._console.status(f"synthesizing {name}" + (" (retry)" if error else ""))
+        source = self._stream(build_messages(name, args, kwargs, error))
+        self._console.status(f"synthesized {name}")
+        return source
+
+    def _completion_kwargs(self, messages: list[dict[str, str]]) -> dict[str, Any]:
+        """litellm kwargs; api_base/api_key/extra_body sent only when set."""
+        kwargs: dict[str, Any] = {
+            "model": self._model,
+            "messages": messages,
+            "stream": True,
+        }
+        if self._api_base and not self._model.startswith("openrouter/"):
+            kwargs["api_base"] = self._api_base
+        if self._api_key:
+            kwargs["api_key"] = self._api_key
+        if self._extra_body:
+            kwargs["extra_body"] = self._extra_body
+        return kwargs
+
+    def _stream(self, messages: list[dict[str, str]]) -> str:
+        """Stream a completion and return the concatenated content."""
+        resp = completion(**self._completion_kwargs(messages))
+        assert isinstance(resp, CustomStreamWrapper)
+
+        parts: list[str] = []
+        for chunk in resp:
+            assert isinstance(chunk, ModelResponseStream)
+            choice = chunk.choices[0]
+            assert isinstance(choice, StreamingChoices)
+            text = choice.delta.content
+            if text:
+                parts.append(text)
+        return "".join(parts)

vybthon-0.1.0.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: vybthon
+Version: 0.1.0
+Summary: Objects whose methods are written by an LLM the moment you call them
+Project-URL: Homepage, https://github.com/bhivam/vybthon
+Project-URL: Repository, https://github.com/bhivam/vybthon
+Author-email: bhivam <shivamkajaria@gmail.com>
+Keywords: codegen,litellm,llm,metaprogramming,openrouter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Requires-Dist: litellm>=1.88.1
+Description-Content-Type: text/markdown
+
+# vybthon
+
+Objects whose methods are written by an LLM the moment you call them. Call any
+method; if it doesn't exist, a model writes it from the name + arguments, runs
+it, and caches the source to `./.vibe_cache/` for instant reuse.
+
+```python
+from vibe import Vibe
+
+v = Vibe.openrouter("openrouter/meta-llama/llama-3.1-8b-instruct")  # set OPENROUTER_API_KEY
+v.reverse_string("hello")   # -> "olleh"
+v.nth_prime(10)             # cached after first call -> 29
+```
+
+## Install
+
+Needs Python ≥ 3.10 and an LLM provider (hosted, or a local Ollama).
+
+```bash
+pip install "git+https://github.com/bhivam/vybthon"   # or: uv add "git+..."
+```
+
+The distribution is `vybthon`; the import is `vibe`. On NixOS, run inside
+`nix develop` (litellm's wheels need `libstdc++`).
+
+## Security
+
+Synthesized code runs via `exec`. LLM output is untrusted — treat every
+generated function as arbitrary code. This is a toy, not a sandbox.

vybthon-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+vibe/__init__.py,sha256=-4kZSCGn-xRVdCNuAOe29LokI5rkAfy53uMITFosurQ,388
+vibe/codegen.py,sha256=puXMRe1j_DmQ_GFEZwUqZ7RFqqm8XsCYCGpDwj8pkB0,6595
+vibe/console.py,sha256=UJIkCdJeWssCqz5uwJmTZ0QqZFBWpyGLF74qSgKSAdk,635
+vibe/core.py,sha256=2E3CxeCvVlqoc71EuiBBC0QC6DKrdyrVW36pnT_TDA4,7420
+vybthon-0.1.0.dist-info/METADATA,sha256=ViBg0SPs9v0gzJTGAbmzSlpMekRo4SktRvApVLvgpTY,1768
+vybthon-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+vybthon-0.1.0.dist-info/RECORD,,

vybthon-0.1.0.dist-info/WHEEL

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