novacode-cli 1.2.0__py3-none-any.whl

novacode_cli/context/_budget.py

@@ -0,0 +1,116 @@
+"""Context budget tracking across middleware layers.
+
+Private to the ``context`` package. Tracks token usage per middleware layer to
+prevent overflow and show which layers consume the most context. Surfaced
+through ``ContextManager.budget``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+from contextvars import ContextVar
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class ContextBudget:
+    """Track and manage context token usage across middleware layers.
+
+    This helps prevent context overflow by monitoring token usage and
+    providing visibility into which middleware layers consume the most context.
+    """
+
+    def __init__(self, max_tokens: int = 50000):
+        """Initialize context budget tracker.
+
+        Args:
+            max_tokens: Maximum allowed tokens before compression/warning.
+        """
+        self.max_tokens = max_tokens
+        self.middleware_usage: dict[str, int] = {}
+        self.total_tokens = 0
+
+    def track_middleware(self, middleware_name: str, context: str | list[Any]) -> int:
+        """Track context usage for a middleware layer.
+
+        Args:
+            middleware_name: Name of the middleware.
+            context: Context content (string or list of messages).
+
+        Returns:
+            Number of tokens used by this middleware.
+        """
+        tokens = self._count_tokens(context)
+        self.middleware_usage[middleware_name] = tokens
+        # Sum, don't accumulate: this is called once per model call with the same
+        # (cached) section, so `+=` grew the total forever and logged a bogus
+        # "budget exceeded" every turn until the log was nothing else.
+        self.total_tokens = sum(self.middleware_usage.values())
+
+        if self.total_tokens > self.max_tokens:
+            logger.warning(
+                f"Context budget exceeded: {self.total_tokens} > {self.max_tokens} "
+                f"tokens. Consider compressing context or reducing middleware layers."
+            )
+
+        return tokens
+
+    def _count_tokens(self, context: str | list[Any]) -> int:
+        """Estimate token count (~4 chars per token for English text)."""
+        if isinstance(context, str):
+            return len(context) // 4
+        elif isinstance(context, list):
+            total = 0
+            for msg in context:
+                if isinstance(msg, dict):
+                    content = msg.get("content", "")
+                    if isinstance(content, str):
+                        total += len(content) // 4
+                    elif isinstance(content, list):
+                        for block in content:
+                            if isinstance(block, dict):
+                                total += len(str(block.get("text", ""))) // 4
+                elif isinstance(msg, str):
+                    total += len(msg) // 4
+            return total
+        return 0
+
+    def reset(self) -> None:
+        """Reset tracking for a new request."""
+        self.middleware_usage.clear()
+        self.total_tokens = 0
+
+
+# Global context budget tracker
+_context_budget: ContextVar[tuple[object, ContextBudget] | None] = ContextVar(
+    "nova_context_budget", default=None
+)
+
+
+def get_context_budget(max_tokens: int = 50000) -> ContextBudget:
+    """Get or create the global context budget tracker.
+
+    Args:
+        max_tokens: Maximum allowed tokens (only used on first call).
+
+    Returns:
+        Global ContextBudget instance.
+    """
+    try:
+        owner = asyncio.current_task() or threading.current_thread()
+    except RuntimeError:
+        owner = threading.current_thread()
+    entry = _context_budget.get()
+    budget = entry[1] if entry and entry[0] is owner else None
+    if budget is None or budget.max_tokens != max_tokens:
+        budget = ContextBudget(max_tokens)
+        _context_budget.set((owner, budget))
+    return budget
+
+
+def reset_context_budget() -> None:
+    """Reset the global context budget tracker."""
+    _context_budget.set(None)

novacode_cli/context/_conversation.py

@@ -0,0 +1,73 @@
+"""Recent-conversation digest from agent state.
+
+Private to the ``context`` package. Used by long-running commands (/research,
+/ralph) so the task they kick off is grounded in what was already discussed with
+the core agent — including for the subagents they spawn, which otherwise run on
+fresh threads with no history. Surfaced through ``ContextManager.digest``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _message_text(msg: Any) -> str:
+    """Extract plain text from a LangChain message's content (str or blocks)."""
+    content = getattr(msg, "content", "")
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            if isinstance(block, dict):
+                if block.get("type") == "text":
+                    parts.append(block.get("text", ""))
+            elif isinstance(block, str):
+                parts.append(block)
+        return "\n".join(parts)
+    return str(content)
+
+
+async def get_recent_conversation_digest(
+    agent: Any,
+    thread_id: str,
+    *,
+    max_turns: int = 10,
+    max_chars: int = 4000,
+) -> str:
+    """Return a compact transcript of the most recent user/assistant turns.
+
+    Reads the agent's checkpointed state for ``thread_id`` and formats the last
+    ``max_turns`` Human/AI turns (tool noise skipped) into a bounded text block.
+    Returns an empty string if there's no history or the state can't be read.
+    """
+    config = {"configurable": {"thread_id": thread_id}}
+    try:
+        state = await agent.aget_state(config)
+    except Exception:  # noqa: BLE001
+        return ""
+
+    values = getattr(state, "values", None) or {}
+    messages = values.get("messages", []) or []
+    if not messages:
+        return ""
+
+    turns: list[str] = []
+    for msg in messages:
+        role = getattr(msg, "type", "") or ""
+        if role not in ("human", "ai"):
+            continue
+        text = _message_text(msg).strip()
+        if not text:
+            continue
+        speaker = "User" if role == "human" else "Assistant"
+        turns.append(f"{speaker}: {text}")
+
+    if not turns:
+        return ""
+
+    turns = turns[-max_turns:]
+    digest = "\n\n".join(turns)
+    if len(digest) > max_chars:
+        digest = "…(earlier turns trimmed)…\n\n" + digest[-max_chars:]
+    return digest

novacode_cli/context/_dynamic.py

@@ -0,0 +1,264 @@
+"""Dynamic context-window detection for Ollama models.
+
+Private to the ``context`` package. Probes a locally-installed Ollama for a
+model's real context length via ``ollama show``, cached for the process
+lifetime. Used by :mod:`novacode_cli.context._analysis` as the first source for
+``get_context_window_size`` (Ollama models only).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import subprocess
+from functools import lru_cache
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# A LAST-RESORT assumption about a local model's context, used only when neither
+# its Modelfile nor ``OLLAMA_CONTEXT_LENGTH`` says (see predicted_local_num_ctx).
+#
+# It used to be the value Nova REQUESTED when loading a model, and so the real
+# limit. Nova now uses Ollama's OpenAI-compatible endpoint, which cannot send
+# ``num_ctx``: the server decides, and this number is no longer enforced by
+# anything. Overridable via ``OLLAMA_NUM_CTX`` to tell Nova what the server uses.
+DEFAULT_OLLAMA_NUM_CTX = 200_000
+
+
+def is_ollama_cloud_model(model_name: str) -> bool:
+    """Whether a model name refers to an Ollama *cloud* model (``:cloud`` suffix).
+
+    Cloud models (e.g. ``qwen3-coder:480b-cloud``, ``deepseek-v4-pro:cloud``) run
+    entirely on Ollama's servers — they are never loaded into local VRAM, so they
+    don't appear in ``ollama ps`` and the local ``num_ctx`` allocation doesn't
+    apply. Their context length comes from ``ollama show`` (which works for cloud
+    models) and is the model's maximum.
+    """
+    name = model_name.lower()
+    return name.endswith("-cloud") or name.endswith(":cloud")
+
+
+def get_ollama_num_ctx() -> int:
+    """The ``num_ctx`` Nova loads Ollama models with (env ``OLLAMA_NUM_CTX``).
+
+    Returns ``DEFAULT_OLLAMA_NUM_CTX`` when unset or malformed.
+    """
+    raw = os.environ.get("OLLAMA_NUM_CTX", "").strip()
+    if raw:
+        try:
+            value = int(raw)
+            if value > 0:
+                return value
+        except ValueError:
+            logger.warning("Invalid OLLAMA_NUM_CTX=%r; using default", raw)
+    return DEFAULT_OLLAMA_NUM_CTX
+
+
+@lru_cache(maxsize=128)
+def get_ollama_modelfile_num_ctx(model_name: str) -> Optional[int]:
+    """``num_ctx`` baked into a model's Modelfile, or None when it sets none.
+
+    Nova talks to Ollama through its OpenAI-compatible endpoint, which cannot
+    carry ``num_ctx``, so the server decides a local model's context — and a
+    Modelfile value is the first thing it uses. Measured: ``tev1:0.8b`` declares
+    ``num_ctx 2050`` and was allocated exactly 2,050 tokens, where Nova had been
+    assuming the 200,000 it used to request.
+    """
+    try:
+        result = subprocess.run(
+            ["ollama", "show", model_name, "--parameters"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    for line in (result.stdout or "").splitlines():
+        parts = line.split()
+        if len(parts) >= 2 and parts[0] == "num_ctx" and parts[-1].isdigit():
+            return int(parts[-1]) or None
+    return None
+
+
+def predicted_local_num_ctx(model_name: str, *, use_dynamic: bool = True) -> int:
+    """The context the server will give a LOCAL model that is not loaded yet.
+
+    In the order Ollama itself applies them: the Modelfile's ``num_ctx``, then
+    the server's ``OLLAMA_CONTEXT_LENGTH``. If neither can be seen from here the
+    answer falls back to :func:`get_ollama_num_ctx`, which is then only a guess:
+    the server's built-in default applies and Nova cannot read it until the
+    model is loaded (after which ``ollama ps`` reports the real figure).
+    """
+    if use_dynamic:
+        baked = get_ollama_modelfile_num_ctx(model_name)
+        if baked:
+            return baked
+    raw = os.environ.get("OLLAMA_CONTEXT_LENGTH", "").strip()
+    if raw.isdigit() and int(raw) > 0:
+        return int(raw)
+    return get_ollama_num_ctx()
+
+
+@lru_cache(maxsize=128)
+def get_ollama_context_length(model_name: str) -> Optional[int]:
+    """Get context length for an Ollama model dynamically.
+
+    Uses caching to avoid repeated Ollama queries. Results are cached
+    for the lifetime of the process.
+
+    Args:
+        model_name: Name of the Ollama model (e.g., "glm-5:cloud")
+
+    Returns:
+        Context length in tokens, or None if not found.
+    """
+    try:
+        result = subprocess.run(
+            ["ollama", "show", model_name],
+            capture_output=True,
+            text=True,
+            # Answers in ~0.1s when healthy; a busy daemon can hang. A failure is
+            # cached for the session anyway, so waiting longer buys nothing.
+            timeout=3,
+        )
+
+        if result.returncode != 0:
+            logger.warning(f"Failed to get context for {model_name}: {result.stderr}")
+            return None
+
+        output = result.stdout
+
+        # Look for a "context length" line, e.g. "context length      202752"
+        for line in output.split("\n"):
+            if "context" in line.lower() and "length" in line.lower():
+                match = re.search(r"(\d+)", line)
+                if match:
+                    context_length = int(match.group(1))
+                    logger.info(
+                        f"Detected context length for {model_name}: "
+                        f"{context_length:,} tokens"
+                    )
+                    return context_length
+
+        logger.warning(f"No context length found for {model_name}")
+        return None
+
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout getting context for {model_name}")
+        return None
+    except FileNotFoundError:
+        logger.error("Ollama not found. Make sure Ollama is installed and in PATH.")
+        return None
+    except Exception as e:  # noqa: BLE001
+        logger.error(f"Error getting context for {model_name}: {e}")
+        return None
+
+
+def _names_match(ps_name: str, model_name: str) -> bool:
+    """Whether an ``ollama ps`` NAME refers to the requested model.
+
+    Handles tag differences: ``gemma3`` vs ``gemma3:latest``,
+    ``qwen3-coder:480b-cloud`` vs ``qwen3-coder``.
+    """
+    ps_name = ps_name.strip()
+    model_name = model_name.strip()
+    if ps_name == model_name:
+        return True
+    return ps_name.split(":", 1)[0] == model_name.split(":", 1)[0]
+
+
+def get_ollama_runtime_info(model_name: str) -> Optional[dict]:
+    """Parse ``ollama ps`` for the running model's actual allocated state.
+
+    ``ollama ps`` reports the *real* runtime values for a loaded model — the
+    ``CONTEXT`` actually allocated (which Ollama may clamp below the requested
+    ``num_ctx`` to fit VRAM) and the ``PROCESSOR`` split (e.g. ``100% GPU`` vs a
+    CPU-offloaded ``48%/52% CPU/GPU``). This is the most accurate source for both
+    context-usage tracking and performance diagnostics.
+
+    Not cached: a model loads after the first request and its allocation can
+    change between runs, so each call reflects the current state.
+
+    Returns:
+        A dict with any of ``{"name", "context", "processor"}`` for the matching
+        model, or ``None`` if Ollama isn't running, has no such model loaded, or
+        the installed Ollama predates the ``CONTEXT`` column.
+    """
+    try:
+        result = subprocess.run(
+            ["ollama", "ps"], capture_output=True, text=True, timeout=3
+        )
+        if result.returncode != 0:
+            return None
+        output = result.stdout
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return None
+
+    # On Windows `capture_output=True` can yield stdout=None even with a 0
+    # returncode, so guard before splitting rather than crashing on None.
+    if not output:
+        return None
+
+    lines = [ln for ln in output.splitlines() if ln.strip()]
+    if len(lines) < 2:  # header only (nothing loaded) or empty
+        return None
+
+    # Columns are separated by runs of 2+ spaces; single spaces inside a field
+    # ("6.6 GB", "100% GPU", "2 minutes from now") are preserved.
+    headers = re.split(r"\s{2,}", lines[0].strip())
+    col = {h.upper(): i for i, h in enumerate(headers)}
+    name_i = col.get("NAME", 0)
+    ctx_i = col.get("CONTEXT")
+    proc_i = col.get("PROCESSOR")
+
+    for line in lines[1:]:
+        fields = re.split(r"\s{2,}", line.strip())
+        if name_i >= len(fields):
+            continue
+        if not _names_match(fields[name_i], model_name):
+            continue
+        info: dict = {"name": fields[name_i]}
+        if ctx_i is not None and ctx_i < len(fields):
+            m = re.search(r"\d+", fields[ctx_i])
+            if m:
+                info["context"] = int(m.group())
+        if proc_i is not None and proc_i < len(fields):
+            info["processor"] = fields[proc_i].strip()
+        return info
+
+    return None
+
+
+def get_ollama_running_context(model_name: str) -> Optional[int]:
+    """The actual allocated context length for a loaded Ollama model, or None.
+
+    Sourced from ``ollama ps`` (see :func:`get_ollama_runtime_info`); this is the
+    authoritative window — what the model was really loaded with — superseding
+    both the architecture max and the requested ``num_ctx``.
+    """
+    info = get_ollama_runtime_info(model_name)
+    return info.get("context") if info else None
+
+
+def check_ollama_offloading(model_name: str) -> Optional[str]:
+    """Return a warning if a loaded Ollama model isn't fully on the GPU.
+
+    CPU offloading (PROCESSOR not ``100% GPU``) drastically slows generation.
+    Returns ``None`` when the model is fully GPU-resident, not loaded, or the
+    PROCESSOR split is unavailable.
+    """
+    info = get_ollama_runtime_info(model_name)
+    if not info:
+        return None
+    processor = info.get("processor")
+    if not processor or "CPU" not in processor.upper():
+        return None  # fully on GPU (or no split reported)
+    return (
+        f"Ollama model '{info.get('name', model_name)}' is partially offloaded to "
+        f"CPU (PROCESSOR: {processor}) — generation will be slow. Free VRAM, lower "
+        f"OLLAMA_NUM_CTX, or use a smaller model to keep it 100% on GPU."
+    )