vybthon 0.1.0__tar.gz

vybthon-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,18 @@
+name: publish
+
+# Build and publish to PyPI when you publish a GitHub Release.
+on:
+  release:
+    types: [published]
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    environment: pypi          # must match the Trusted Publisher "Environment name"
+    permissions:
+      id-token: write          # required for PyPI trusted publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv build          # writes sdist + wheel to dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

vybthon-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# vibe-synthesized function cache
+.vibe_cache/
+
+# Secrets
+.env

vybthon-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

vybthon-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,29 @@
+# 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/examples/demo.py

@@ -0,0 +1,74 @@
+"""Prototype: a contact-list importer that cleans messy exported data.
+
+A familiar chore — you exported contacts from somewhere and the rows are a mess:
+inconsistent name casing, five different phone formats, mixed-case emails, the
+odd broken address. This prototype normalizes and validates every row, then
+prints a tidy report plus a breakdown by email provider.
+
+The interesting part: none of the cleaning or validation logic is written by
+hand. Each ``v.<something>(...)`` call is a function that doesn't exist yet —
+the model writes it from the name and argument types on first call, it runs, and
+the source is cached to ./.vibe_cache/ for instant reuse afterwards.
+
+Run inside `nix develop` (so libstdc++ is on LD_LIBRARY_PATH) with an
+OPENROUTER_API_KEY in your environment:
+
+    uv run python examples/demo.py
+"""
+
+from collections import Counter
+
+from vibe import Vibe
+
+RAW_CONTACTS = [
+    {"name": "  ada LOVELACE ", "phone": "(415) 555-0132", "email": "Ada@Gmail.com"},
+    {"name": "alan turing", "phone": "415.555.0199", "email": "alan.turing@bletchley.uk"},
+    {"name": "GRACE hopper", "phone": "+1 415 555 0150", "email": "grace@navy.mil"},
+    {"name": "katherine Johnson", "phone": "4155550177", "email": "not-an-email"},
+    {"name": "linus  torvalds", "phone": "415-555-0164", "email": "Linus@gmail.com"},
+]
+
+
+def main() -> None:
+    v = Vibe.openrouter(
+        model="openrouter/meta-llama/Llama-3.1-8B-Instruct",
+        verbose=True,
+    )
+
+    providers: Counter[str] = Counter()
+    rows: list[tuple[str, str, str, bool]] = []
+
+    for raw in RAW_CONTACTS:
+        name = v.normalize_full_name(raw["name"])
+        phone = v.format_phone_number_e164(raw["phone"], "US")
+        email = raw["email"].strip().lower()
+        valid = v.is_valid_email_address(email)
+
+        if valid:
+            shown_email = v.mask_email_address(email)
+            provider = v.email_provider_from_address(email)
+            if provider:  # synthesized code may return None on odd input
+                providers[provider] += 1
+        else:
+            shown_email = "<invalid>"
+
+        rows.append((name, phone, shown_email, valid))
+
+    # --- cleaned report -------------------------------------------------
+    print(f"\n{'NAME':<20}{'PHONE':<18}{'EMAIL':<22}STATUS")
+    print("-" * 66)
+    for name, phone, email, valid in rows:
+        # str(): synthesized functions may return None, which can't be formatted.
+        status = "ok" if valid else "REVIEW"
+        print(f"{str(name):<20}{str(phone):<18}{str(email):<22}{status}")
+
+    flagged = sum(1 for *_, valid in rows if not valid)
+    print(f"\n{len(rows)} contacts imported, {flagged} flagged for review")
+
+    print("\ncontacts by email provider:")
+    for provider, count in providers.most_common():
+        print(f"  {provider:<12} {count}")
+
+
+if __name__ == "__main__":
+    main()

vybthon-0.1.0/flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1780749050,
+        "narHash": "sha256-3av0pIjlOWQ6rDbNOmpUSvbNnJkGORQKKjb4LtCZsIY=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "a799d3e3886da994fa307f817a6bc705ae538eeb",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

vybthon-0.1.0/flake.nix

@@ -0,0 +1,27 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+  };
+
+  outputs = { self, nixpkgs }:
+    let
+      supportedSystems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
+      forEachSupportedSystem = f: nixpkgs.lib.genAttrs supportedSystems (system: f {
+        pkgs = import nixpkgs { inherit system; };
+      });
+    in
+    {
+      devShells = forEachSupportedSystem ({ pkgs }: {
+        default = pkgs.mkShell {
+          packages = with pkgs; [
+            python3
+            uv
+          ];
+
+          # Precompiled Python wheels (e.g. litellm's `tokenizers`) link
+          # against a standard libstdc++; expose it so they load at runtime.
+          LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [ pkgs.stdenv.cc.cc.lib ];
+        };
+      });
+    };
+}

vybthon-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "vybthon"
+version = "0.1.0"
+description = "Objects whose methods are written by an LLM the moment you call them"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "bhivam", email = "shivamkajaria@gmail.com" }]
+keywords = ["llm", "codegen", "metaprogramming", "litellm", "openrouter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Code Generators",
+]
+dependencies = [
+    "litellm>=1.88.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/bhivam/vybthon"
+Repository = "https://github.com/bhivam/vybthon"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vibe"]

vybthon-0.1.0/pyrightconfig.json

@@ -0,0 +1,7 @@
+{
+  "venvPath": ".",
+  "venv": ".venv",
+  "pythonVersion": "3.13",
+  "extraPaths": ["src"],
+  "include": ["src", "examples"]
+}

vybthon-0.1.0/src/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"]

vybthon-0.1.0/src/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

vybthon-0.1.0/src/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()