basemode 0.1.0__py3-none-any.whl

basemode/__init__.py

@@ -0,0 +1,5 @@
+from .continue_ import branch_text, continue_text
+from .detect import detect_strategy
+from .params import GenerationParams
+
+__all__ = ["continue_text", "branch_text", "detect_strategy", "GenerationParams"]

basemode/cli.py

@@ -0,0 +1,136 @@
+import asyncio
+import sys
+from typing import Annotated
+
+import typer
+from rich.columns import Columns
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .continue_ import branch_text, continue_text
+from .detect import detect_strategy, normalize_model
+from .models import list_models, list_providers
+from .strategies import REGISTRY
+
+app = typer.Typer(help="Make any LLM do raw text continuation.")
+console = Console()
+
+_BRANCH_COLORS = ["green", "blue", "yellow", "magenta", "cyan"]
+
+
+def _read_prefix(prefix: str | None) -> str | None:
+    """Return prefix from arg, stdin pipe, or None."""
+    if prefix is not None:
+        return prefix
+    if not sys.stdin.isatty():
+        return sys.stdin.read()
+    return None
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    prefix: Annotated[str | None, typer.Argument(help="Text to continue (or pipe via stdin)")] = None,
+    model: Annotated[str, typer.Option("-m", "--model")] = "gpt-4o-mini",
+    n: Annotated[int, typer.Option("-n", "--branches", help="Number of parallel continuations")] = 1,
+    max_tokens: Annotated[int, typer.Option("--max-tokens")] = 200,
+    temperature: Annotated[float, typer.Option("-t", "--temperature")] = 0.9,
+    strategy: Annotated[str | None, typer.Option("-s", "--strategy")] = None,
+    show_strategy: Annotated[bool, typer.Option("--show-strategy")] = False,
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+
+    text = _read_prefix(prefix)
+    if text is None:
+        console.print(ctx.get_help())
+        return
+
+    prefix = text.rstrip("\n")
+
+    if show_strategy:
+        strat = detect_strategy(normalize_model(model), strategy)
+        console.print(f"[dim]strategy: {strat.name}[/dim]")
+
+    if n == 1:
+        asyncio.run(_stream_one(prefix, model, max_tokens, temperature, strategy))
+    else:
+        asyncio.run(_stream_branches(prefix, model, n, max_tokens, temperature, strategy))  # noqa: E501
+
+
+async def _stream_one(prefix: str, model: str, max_tokens: int, temperature: float, strategy: str | None) -> None:
+    console.print(f"[dim]{prefix}[/dim]", end="")
+    async for token in continue_text(prefix, model, max_tokens=max_tokens, temperature=temperature, strategy=strategy):
+        console.print(token, end="")
+    console.print()
+
+
+async def _stream_branches(
+    prefix: str, model: str, n: int, max_tokens: int, temperature: float, strategy: str | None
+) -> None:
+    buffers: list[list[str]] = [[] for _ in range(n)]
+    console.print(f"[dim]{prefix}[/dim]\n")
+
+    async for idx, token in branch_text(
+        prefix, model, n=n, max_tokens=max_tokens, temperature=temperature, strategy=strategy
+    ):
+        buffers[idx].append(token)
+
+    panels = []
+    for i, buf in enumerate(buffers):
+        color = _BRANCH_COLORS[i % len(_BRANCH_COLORS)]
+        text = Text(prefix, style="dim")
+        text.append("".join(buf), style=color)
+        panels.append(Panel(text, title=f"[{color}]Branch {i + 1}[/{color}]"))
+
+    console.print(Columns(panels, equal=True))
+
+
+@app.command()
+def models(
+    provider: Annotated[str | None, typer.Option("-p", "--provider")] = None,
+    search: Annotated[str | None, typer.Option("-s", "--search")] = None,
+    available: Annotated[bool, typer.Option("-a", "--available", help="Only show models with keys set")] = False,
+) -> None:
+    """List available models."""
+    results = list_models(provider=provider, search=search, available_only=available)
+    if not results:
+        console.print("[yellow]No models found.[/yellow]")
+        return
+
+    table = Table("Model", show_header=True, header_style="bold")
+    for m in results:
+        table.add_row(m)
+    console.print(table)
+
+
+@app.command()
+def providers() -> None:
+    """List all known providers."""
+    for p in list_providers():
+        console.print(p)
+
+
+@app.command()
+def strategies() -> None:
+    """List available continuation strategies."""
+    table = Table("Name", "Description", show_header=True, header_style="bold")
+    descriptions = {
+        "completion": "OpenAI /completions endpoint — for true base models",
+        "prefill": "Anthropic assistant prefill trick",
+        "system": "System prompt coercion — generic fallback for any chat model",
+        "few_shot": "Few-shot examples in system prompt — for stubborn models",
+        "fim": "Fill-in-the-middle tokens — DeepSeek, StarCoder, CodeLlama",
+    }
+    for name in REGISTRY:
+        table.add_row(name, descriptions.get(name, ""))
+    console.print(table)
+
+
+@app.command()
+def info(model: Annotated[str, typer.Argument(help="Model name to inspect")]) -> None:
+    """Show which strategy would be used for a given model."""
+    strat = detect_strategy(model)
+    console.print(f"[bold]{model}[/bold] → [green]{strat.name}[/green]")

basemode/continue_.py

@@ -0,0 +1,56 @@
+import asyncio
+from collections.abc import AsyncGenerator
+
+from .detect import detect_strategy, normalize_model
+from .params import GenerationParams
+
+
+async def continue_text(
+    prefix: str,
+    model: str = "gpt-4o-mini",
+    *,
+    max_tokens: int = 200,
+    temperature: float = 0.9,
+    strategy: str | None = None,
+    **extra,
+) -> AsyncGenerator[str, None]:
+    """Stream a single continuation."""
+    model = normalize_model(model)
+    params = GenerationParams(model=model, max_tokens=max_tokens, temperature=temperature, extra=extra)
+    strat = detect_strategy(model, strategy)
+    async for token in strat.stream(prefix, params):
+        yield token
+
+
+async def branch_text(
+    prefix: str,
+    model: str = "gpt-4o-mini",
+    *,
+    n: int = 4,
+    max_tokens: int = 200,
+    temperature: float = 0.9,
+    strategy: str | None = None,
+    **extra,
+) -> AsyncGenerator[tuple[int, str], None]:
+    """Stream n parallel continuations as (branch_idx, token) tuples."""
+    model = normalize_model(model)
+    params = GenerationParams(model=model, max_tokens=max_tokens, temperature=temperature, extra=extra)
+    strat = detect_strategy(model, strategy)
+
+    queue: asyncio.Queue[tuple[int, str] | None] = asyncio.Queue()
+
+    async def run_branch(idx: int) -> None:
+        async for token in strat.stream(prefix, params):
+            await queue.put((idx, token))
+        await queue.put(None)
+
+    tasks = [asyncio.create_task(run_branch(i)) for i in range(n)]
+    done = 0
+    while done < n:
+        item = await queue.get()
+        if item is None:
+            done += 1
+        else:
+            yield item
+
+    await asyncio.gather(*tasks)

basemode/detect.py

@@ -0,0 +1,64 @@
+from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
+
+from .strategies import (
+    REGISTRY,
+    CompletionStrategy,
+    ContinuationStrategy,
+    FIMStrategy,
+    PrefillStrategy,
+    SystemPromptStrategy,
+)
+
+# Models that use the native completions API
+_COMPLETION_MODELS = {
+    "gpt-3.5-turbo-instruct",
+    "davinci-002",
+    "babbage-002",
+}
+_COMPLETION_SUBSTRINGS = ["text-davinci", "text-curie", "text-babbage", "text-ada"]
+
+# Models where FIM is the right move
+_FIM_SUBSTRINGS = ["deepseek-coder", "starcoder", "codellama", "fim"]
+
+# Provider prefix to add when litellm can't auto-detect from model name alone
+_PREFIX_MAP = {
+    "claude": "anthropic",
+    "gemini": "gemini",
+    "command": "cohere",
+}
+
+
+def normalize_model(model: str) -> str:
+    """Add provider prefix if litellm can't resolve the model name."""
+    if "/" in model:
+        return model
+    try:
+        get_llm_provider(model)
+        return model
+    except Exception:
+        m = model.lower()
+        for fragment, provider in _PREFIX_MAP.items():
+            if fragment in m:
+                return f"{provider}/{model}"
+        return model
+
+
+def detect_strategy(model: str, override: str | None = None) -> ContinuationStrategy:
+    if override:
+        if override not in REGISTRY:
+            valid = ", ".join(REGISTRY)
+            raise ValueError(f"Unknown strategy {override!r}. Valid: {valid}")
+        return REGISTRY[override]()
+
+    m = model.lower()
+
+    if "claude" in m:
+        return PrefillStrategy()
+
+    if model in _COMPLETION_MODELS or any(s in m for s in _COMPLETION_SUBSTRINGS):
+        return CompletionStrategy()
+
+    if any(s in m for s in _FIM_SUBSTRINGS):
+        return FIMStrategy()
+
+    return SystemPromptStrategy()

basemode/models.py

@@ -0,0 +1,28 @@
+import litellm
+
+from .settings import settings
+
+
+def list_models(
+    provider: str | None = None,
+    search: str | None = None,
+    available_only: bool = False,
+) -> list[str]:
+    by_provider: dict[str, list[str]] = litellm.models_by_provider
+
+    if available_only:
+        providers = settings.available_providers
+        models = [m for p in providers for m in by_provider.get(p, [])]
+    elif provider:
+        models = by_provider.get(provider, [])
+    else:
+        models = [m for ms in by_provider.values() for m in ms]
+
+    if search:
+        models = [m for m in models if search.lower() in m.lower()]
+
+    return sorted(set(models))
+
+
+def list_providers() -> list[str]:
+    return sorted(litellm.models_by_provider.keys())

basemode/params.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class GenerationParams:
+    model: str
+    max_tokens: int = 200
+    temperature: float = 0.9
+    extra: dict = field(default_factory=dict)

basemode/settings.py

@@ -0,0 +1,47 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _find_env() -> Path | None:
+    for p in [Path(".env"), Path(__file__).parent.parent.parent / ".env"]:
+        if p.exists():
+            return p
+    return None
+
+
+# Load into os.environ so litellm can pick up keys directly.
+_env_path = _find_env()
+if _env_path:
+    load_dotenv(_env_path, override=False)
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=_env_path, extra="allow")
+
+    openai_api_key: str = ""
+    anthropic_api_key: str = ""
+    openrouter_api_key: str = ""
+    groq_api_key: str = ""
+    gemini_api_key: str = ""
+    together_api_key: str = ""
+
+    @property
+    def available_providers(self) -> list[str]:
+        return [
+            provider
+            for provider, key in [
+                ("openai", self.openai_api_key),
+                ("anthropic", self.anthropic_api_key),
+                ("openrouter", self.openrouter_api_key),
+                ("groq", self.groq_api_key),
+                ("gemini", self.gemini_api_key),
+                ("together_ai", self.together_api_key),
+            ]
+            if key
+        ]
+
+
+settings = Settings()

basemode/strategies/__init__.py

@@ -0,0 +1,27 @@
+from .base import ContinuationStrategy
+from .completion import CompletionStrategy
+from .few_shot import FewShotStrategy
+from .fim import FIMStrategy
+from .prefill import PrefillStrategy
+from .system import SystemPromptStrategy
+
+REGISTRY: dict[str, type[ContinuationStrategy]] = {
+    s.name: s
+    for s in [
+        CompletionStrategy,
+        PrefillStrategy,
+        SystemPromptStrategy,
+        FewShotStrategy,
+        FIMStrategy,
+    ]
+}
+
+__all__ = [
+    "ContinuationStrategy",
+    "CompletionStrategy",
+    "FewShotStrategy",
+    "FIMStrategy",
+    "PrefillStrategy",
+    "SystemPromptStrategy",
+    "REGISTRY",
+]

basemode/strategies/base.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+
+from ..params import GenerationParams
+
+
+class ContinuationStrategy(ABC):
+    name: str
+
+    @abstractmethod
+    def stream(self, prefix: str, params: GenerationParams) -> AsyncGenerator[str, None]: ...
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"

basemode/strategies/completion.py

@@ -0,0 +1,27 @@
+"""OpenAI-compatible /completions endpoint — works natively with base models."""
+from collections.abc import AsyncGenerator
+
+import litellm
+
+from ..params import GenerationParams
+from .base import ContinuationStrategy
+
+
+class CompletionStrategy(ContinuationStrategy):
+    """Uses the text completions API. Best for true base models (davinci, etc.)."""
+
+    name = "completion"
+
+    async def stream(self, prefix: str, params: GenerationParams) -> AsyncGenerator[str, None]:
+        response = await litellm.atext_completion(
+            model=params.model,
+            prompt=prefix,
+            max_tokens=params.max_tokens,
+            temperature=params.temperature,
+            stream=True,
+            **params.extra,
+        )
+        async for chunk in response:
+            token = chunk.choices[0].text or ""
+            if token:
+                yield token

basemode/strategies/few_shot.py

@@ -0,0 +1,69 @@
+"""Few-shot coercion — for stubborn models that ignore system prompts."""
+from collections.abc import AsyncGenerator
+
+import litellm
+
+from ..params import GenerationParams
+from .base import ContinuationStrategy
+from .utils import needs_leading_space, normalize_prefix
+
+# Varied examples: fiction, technical, poetry, dialogue
+_EXAMPLES = [
+    (
+        "The experiment had been running for three days when Dr. Chen noticed the anomaly.",
+        " At first she thought it was a measurement error—the kind that comes from",
+    ),
+    (
+        "To install the package, first ensure you have Python 3.11 or higher.",
+        " Then run the following command in your terminal:\n\n```\npip install",
+    ),
+    (
+        "the rain comes down like static",
+        "\nbetween stations, the city\nblurs into signal",
+    ),
+    (
+        "Look, I'm just saying—if you'd been there, you'd understand why I had to",
+        " make that call. There was no good option. Either way, someone was going to",
+    ),
+]
+
+
+def _build_system_prompt() -> str:
+    examples = "\n\n".join(
+        f'Input: """{inp}"""\nOutput: """{out}"""' for inp, out in _EXAMPLES
+    )
+    return (
+        "You continue text. Given input text, output only the natural continuation "
+        "with no preamble or acknowledgment. Examples:\n\n" + examples
+    )
+
+
+_SYSTEM_PROMPT = _build_system_prompt()
+
+
+class FewShotStrategy(ContinuationStrategy):
+    """Few-shot examples in system prompt. For models that ignore plain instructions."""
+
+    name = "few_shot"
+
+    async def stream(self, prefix: str, params: GenerationParams) -> AsyncGenerator[str, None]:
+        response = await litellm.acompletion(
+            model=params.model,
+            messages=[
+                {"role": "system", "content": _SYSTEM_PROMPT},
+                {"role": "user", "content": normalize_prefix(prefix)},
+            ],
+            max_tokens=params.max_tokens,
+            temperature=params.temperature,
+            stream=True,
+            **params.extra,
+        )
+        first = True
+        async for chunk in response:
+            token = chunk.choices[0].delta.content or ""
+            if not token:
+                continue
+            if first and needs_leading_space(prefix, token):
+                token = " " + token
+            first = False
+            yield token

basemode/strategies/fim.py

@@ -0,0 +1,44 @@
+"""Fill-in-the-middle — for models that support FIM tokens natively."""
+from collections.abc import AsyncGenerator
+
+import litellm
+
+from ..params import GenerationParams
+from .base import ContinuationStrategy
+
+# Token formats by model family
+_FIM_FORMATS = {
+    "deepseek": ("<｜fim▁begin｜>", "<｜fim▁hole｜>", "<｜fim▁end｜>"),
+    "starcoder": ("<fim_prefix>", "<fim_suffix>", "<fim_middle>"),
+    "codellama": ("▁<PRE>", "▁<SUF>", "▁<MID>"),
+}
+
+
+def _fim_prompt(prefix: str, model: str) -> str:
+    for key, (pre, suf, mid) in _FIM_FORMATS.items():
+        if key in model.lower():
+            return f"{pre}{prefix}{suf}{mid}"
+    # Generic fallback
+    pre, suf, mid = _FIM_FORMATS["starcoder"]
+    return f"{pre}{prefix}{suf}{mid}"
+
+
+class FIMStrategy(ContinuationStrategy):
+    """Fill-in-the-middle via text completion. DeepSeek, StarCoder, CodeLlama."""
+
+    name = "fim"
+
+    async def stream(self, prefix: str, params: GenerationParams) -> AsyncGenerator[str, None]:
+        prompt = _fim_prompt(prefix, params.model)
+        response = await litellm.atext_completion(
+            model=params.model,
+            prompt=prompt,
+            max_tokens=params.max_tokens,
+            temperature=params.temperature,
+            stream=True,
+            **params.extra,
+        )
+        async for chunk in response:
+            token = chunk.choices[0].text or ""
+            if token:
+                yield token

basemode/strategies/prefill.py

@@ -0,0 +1,45 @@
+"""Anthropic prefill trick — force continuation by seeding the assistant turn."""
+from collections.abc import AsyncGenerator
+
+import litellm
+
+from ..params import GenerationParams
+from .base import ContinuationStrategy
+
+# How many trailing chars of the prefix to use as the assistant seed.
+# Long enough that the model clearly understands it's mid-sentence.
+SEED_LEN = 50
+
+
+class PrefillStrategy(ContinuationStrategy):
+    """
+    Works by splitting the prefix: the first part goes in the user turn,
+    the last SEED_LEN characters become the start of the assistant turn.
+    The model is forced to continue from exactly where the prefix ends.
+    """
+
+    name = "prefill"
+
+    async def stream(self, prefix: str, params: GenerationParams) -> AsyncGenerator[str, None]:
+        if len(prefix) <= SEED_LEN:
+            user_content = "Continue:"
+            assistant_seed = prefix
+        else:
+            user_content = prefix[:-SEED_LEN]
+            assistant_seed = prefix[-SEED_LEN:]
+
+        response = await litellm.acompletion(
+            model=params.model,
+            messages=[
+                {"role": "user", "content": user_content},
+                {"role": "assistant", "content": assistant_seed},
+            ],
+            max_tokens=params.max_tokens,
+            temperature=params.temperature,
+            stream=True,
+            **params.extra,
+        )
+        async for chunk in response:
+            token = chunk.choices[0].delta.content or ""
+            if token:
+                yield token

basemode/strategies/system.py

@@ -0,0 +1,69 @@
+"""System prompt coercion — works on any chat model."""
+from collections.abc import AsyncGenerator
+
+import litellm
+
+from ..params import GenerationParams
+from .base import ContinuationStrategy
+from .utils import needs_leading_space, normalize_prefix
+
+SYSTEM_PROMPT = """\
+You are a text continuation engine. Your only function is to extend the provided \
+text naturally, as if you wrote it yourself. Rules:
+- Output ONLY the continuation — no acknowledgment, preamble, or commentary
+- Continue in the exact same voice, style, and register
+- Begin immediately with the next character that naturally follows
+- Never start with "Sure", "Of course", "Certainly", or any other acknowledgment"""
+
+# Gemini 2.5+ models are "thinking" models that consume tokens on internal reasoning
+# before producing output. Without a thinking budget, max_tokens is exhausted by
+# thoughts and the visible output is empty or truncated.
+_THINKING_MODELS = {"gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.5-flash-lite"}
+_THINKING_BUDGET = 1024
+_THINKING_MIN_OUTPUT = 512
+
+
+def _is_thinking_model(model: str) -> bool:
+    m = model.lower().split("/")[-1]
+    return any(t in m for t in _THINKING_MODELS)
+
+
+def _thinking_kwargs(params: GenerationParams) -> dict:
+    if not _is_thinking_model(params.model):
+        return {}
+    return {
+        "thinking": {"type": "enabled", "budget_tokens": _THINKING_BUDGET},
+        "max_tokens": max(params.max_tokens, _THINKING_BUDGET + _THINKING_MIN_OUTPUT),
+    }
+
+
+class SystemPromptStrategy(ContinuationStrategy):
+    """Generic coercion via system prompt. Fallback for any chat model."""
+
+    name = "system"
+
+    async def stream(self, prefix: str, params: GenerationParams) -> AsyncGenerator[str, None]:
+        kwargs = {
+            "max_tokens": params.max_tokens,
+            "temperature": params.temperature,
+            **_thinking_kwargs(params),  # may override max_tokens for thinking models
+            **params.extra,
+        }
+        response = await litellm.acompletion(
+            model=params.model,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": normalize_prefix(prefix)},
+            ],
+            stream=True,
+            **kwargs,
+        )
+        first = True
+        async for chunk in response:
+            token = chunk.choices[0].delta.content or ""
+            if not token:
+                continue
+            if first and needs_leading_space(prefix, token):
+                token = " " + token
+            first = False
+            yield token

basemode/strategies/utils.py

@@ -0,0 +1,26 @@
+def normalize_prefix(prefix: str) -> str:
+    """Ensure prefix ends with exactly one space for the model input.
+
+    Chat models respond without a leading space, so we strip trailing whitespace
+    and add exactly one space. This makes the model output tokens that join
+    correctly when we prepend a space to the first token if needed.
+
+    Not applied to completion/prefill strategies — they handle boundaries natively.
+    """
+    return prefix.rstrip() + " "
+
+
+def needs_leading_space(prefix: str, first_token: str) -> bool:
+    """Return True if a space must be injected between prefix and first_token.
+
+    After sending normalize_prefix(prefix) to the model, the model outputs
+    first_token without a leading space. If the original prefix didn't end
+    with whitespace, the space was consumed in the model input and must be
+    restored so that prefix + tokens is correct text.
+    """
+    return (
+        bool(prefix)
+        and not prefix[-1].isspace()
+        and bool(first_token)
+        and not first_token[0].isspace()
+    )

basemode-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: basemode
+Version: 0.1.0
+Summary: Make any LLM do raw text continuation
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4.0.0
+Requires-Dist: litellm>=1.63.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0

basemode-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+basemode/__init__.py,sha256=fdPLFqO2bCXcZeTFmxhM3rJQ3_6ByBmcekSGQ01GXcg,206
+basemode/cli.py,sha256=HYrPF3mT1Fkl2d_l04fDtMkLGWpsBypB540iQ4cqvcg,4861
+basemode/continue_.py,sha256=iquyxU8beFpoEDSL_HO0nxavfoEsTX3U7875cmqEh-4,1659
+basemode/detect.py,sha256=T1bx3NaPrMDEN-YBDWc8lydERkjQZE6cAgPN_5GA1hM,1762
+basemode/models.py,sha256=l4rcGJQ4KrBeldtS9drBxfzIVo3jE_Z399u3-RXQoLI,738
+basemode/params.py,sha256=_2tycQWR5vZmj2L3vXcIGil3zgZaJCEtCcX9HAU7dRo,194
+basemode/settings.py,sha256=qlvrr_73O2erHxxmbx1HmpOwfop-qIu9mAeuMSqWXsc,1244
+basemode/strategies/__init__.py,sha256=AvdKHyJKvl2UY2bovrVEOvy_JQwhxE8j5I3O7Dqrqyw,624
+basemode/strategies/base.py,sha256=GPj7_hWm-XeaXVqpY193l_Dn-GSym3OcVuv0qYcHR8c,360
+basemode/strategies/completion.py,sha256=7ywtAtylzyvSsrujNPM3WUJUbhW71KxQ07NMTtihYJc,870
+basemode/strategies/few_shot.py,sha256=4qpEyMaXIWJ_8g650WPwLLQCsSqYqYwtiUrJqTOI6w4,2344
+basemode/strategies/fim.py,sha256=EywjHVkQgUooUSs-qTG0pBm5V_SrUfNEmL4IfWIqxjs,1445
+basemode/strategies/prefill.py,sha256=HqhlkQJXb571xY5MMoRmvrLUCPB8wkIAVOD31zlQpC0,1528
+basemode/strategies/system.py,sha256=pXCtqDIAOqbAQeiXb8jhxBqQmDWongzZUoFaHGBaK-c,2587
+basemode/strategies/utils.py,sha256=K7qgf3TN_2JRXclDFKPs5BT3hscdr2tOH_pJOx62e2s,1047
+basemode-0.1.0.dist-info/METADATA,sha256=KeIcJaZTCNfsEmi6jHwTUXde3NRI0wL6lM3TWPOXtmE,315
+basemode-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+basemode-0.1.0.dist-info/entry_points.txt,sha256=N9pXaPSXGtGOreQNEuSYXKSh7gK27Dc-3sKmOHCqLgQ,46
+basemode-0.1.0.dist-info/RECORD,,

basemode-0.1.0.dist-info/WHEEL

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

basemode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+basemode = basemode.cli:app