novacode-cli 1.2.0__py3-none-any.whl

novacode_cli/context/manager.py

@@ -0,0 +1,101 @@
+"""The one public entry point for context-window management.
+
+``ContextManager`` is a thin, model-aware facade over the package's private
+modules (``_analysis``, ``_budget``, ``_model_config``, ``_dynamic``,
+``_conversation``). Callers construct it with a model name and call its methods
+instead of importing scattered free functions.
+
+    cm = ContextManager(model_name)
+    cm.window_size()                       # int
+    cm.breakdown(messages, tools=tools)     # ContextBreakdown
+    cm.model_config()                      # ModelConfig
+
+Model-independent operations don't require a model name:
+
+    ContextManager().budget()              # ContextBudget (process-global)
+    await ContextManager().digest(agent, thread_id)  # str
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from novacode_cli.context._analysis import (
+    ContextBreakdown,
+    build_context_breakdown,
+    get_context_window_size,
+)
+from novacode_cli.context._budget import ContextBudget
+from novacode_cli.context._conversation import get_recent_conversation_digest
+from novacode_cli.context._model_config import ModelConfig, get_model_config
+
+if TYPE_CHECKING:
+    from langchain_core.messages import BaseMessage
+
+
+class ContextManager:
+    """Model-aware facade for all context-window operations."""
+
+    def __init__(self, model_name: str | None = None, *, use_dynamic: bool = True):
+        """Create a context manager.
+
+        Args:
+            model_name: Model to bind analysis/config operations to. May be None
+                for model-independent operations (``budget``, ``digest``).
+            use_dynamic: Whether to consult Ollama for dynamic window detection.
+        """
+        self.model_name = model_name
+        self.use_dynamic = use_dynamic
+        self._budget = None
+
+    def _require_model(self) -> str:
+        if not self.model_name:
+            raise ValueError(
+                "ContextManager was created without a model_name; this operation requires one."
+            )
+        return self.model_name
+
+    # ── Analysis (model-bound) ──────────────────────────────────────────
+
+    def window_size(self) -> int:
+        """Context window size in tokens for the bound model."""
+        return get_context_window_size(self._require_model(), use_dynamic=self.use_dynamic)
+
+    def breakdown(
+        self, messages: list[BaseMessage], tools: list[Any] | None = None
+    ) -> ContextBreakdown:
+        """Token breakdown of ``messages`` against the bound model's window.
+
+        Args:
+            messages: Conversation messages from agent state.
+            tools: Tool definitions bound to the model, if known — their schemas
+                are a permanent per-request cost and belong in the baseline.
+        """
+        return build_context_breakdown(
+            messages, self._require_model(), use_dynamic=self.use_dynamic, tools=tools
+        )
+
+    def model_config(self) -> ModelConfig:
+        """Per-model tuning config (budgets, thresholds, cost) for the bound model."""
+        return get_model_config(self._require_model(), use_dynamic=self.use_dynamic)
+
+    # ── Model-independent ───────────────────────────────────────────────
+
+    def budget(self, max_tokens: int = 50000) -> ContextBudget:
+        """The process-global middleware context-budget tracker."""
+        if self._budget is None or self._budget.max_tokens != max_tokens:
+            self._budget = ContextBudget(max_tokens)
+        return self._budget
+
+    async def digest(
+        self,
+        agent: Any,
+        thread_id: str,
+        *,
+        max_turns: int = 10,
+        max_chars: int = 4000,
+    ) -> str:
+        """Compact transcript of the most recent user/assistant turns."""
+        return await get_recent_conversation_digest(
+            agent, thread_id, max_turns=max_turns, max_chars=max_chars
+        )

novacode_cli/context/observations.py

@@ -0,0 +1,65 @@
+"""Request-local references for byte-identical successful file observations.
+
+Tools always execute. Only duplicate text in the final dispatch view changes;
+checkpoint messages, call arguments, ordering and full recovery stay intact.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from langchain_core.messages import AIMessage, ToolMessage
+
+if TYPE_CHECKING:
+    from langchain_core.messages import AnyMessage
+
+MIN_OBSERVATION_CHARS = 2_048
+
+
+def compact_observations(messages: list[AnyMessage]) -> list[AnyMessage]:
+    """Reference an earlier identical read in this view, never a cached read.
+
+    Keys include the exact arguments and text, rather than just the file path.
+    A read after an edit must have actually returned the same bytes to qualify.
+    Sources must survive in the same request; rebuilding from original messages
+    on every dispatch prevents dangling references after compaction or resume.
+    Nontext results and failed reads are never rewritten.
+    """
+    result = list(messages)
+    pending: dict[str, str] = {}
+    seen: dict[tuple[str, str], int] = {}
+    for index, message in enumerate(messages):
+        if isinstance(message, AIMessage):
+            for call in message.tool_calls:
+                call_id = call.get("id")
+                if call_id:
+                    pending.pop(call_id, None)
+                    if call["name"] == "read_file":
+                        pending[call_id] = json.dumps(call["args"], sort_keys=True)
+        elif isinstance(message, ToolMessage):
+            arguments = pending.pop(message.tool_call_id, None)
+            if (
+                arguments is None
+                or message.name != "read_file"
+                or message.status == "error"
+                or not isinstance(message.content, str)
+                or len(message.content) < MIN_OBSERVATION_CHARS
+            ):
+                continue
+            key = (arguments, message.content)
+            if key not in seen:
+                seen[key] = index
+                continue
+            source = seen[key] + 1
+            result[index] = message.model_copy(
+                update={
+                    "content": (
+                        "[Identical read_file output: this fresh read returned exactly the text "
+                        f"retained in request message {source} "
+                        "(counting conversation messages from 1, excluding the system prompt). "
+                        "Use that full result; no new contents omitted.]"
+                    )
+                }
+            )
+    return result

novacode_cli/context/pressure.py

@@ -0,0 +1,168 @@
+"""One shared policy for reacting to context pressure.
+
+Every renderer must apply the SAME rule. It previously lived inline in
+``tui/app.py`` only, so the console path recorded the breakdown and then did
+nothing — no warning, no compaction, straight into the provider's limit on a
+long session.
+
+Kept pure (no agent, no model, no I/O) so the policy is unit-testable without a
+running agent and cannot drift between surfaces.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from novacode_cli.context._analysis import (
+    CONTEXT_CRITICAL_THRESHOLD,
+    CONTEXT_WARNING_THRESHOLD,
+    MIN_RESERVE_TOKENS,
+    compact_threshold_pct,
+)
+
+
+class PressureAction(Enum):
+    """What the caller should do about current context usage."""
+
+    NONE = "none"
+    """Comfortably below the warning threshold — do nothing."""
+
+    WARN = "warn"
+    """Past the warning threshold — tell the user, suggest /compact."""
+
+    COMPACT = "compact"
+    """Past the auto-compaction threshold — compact now."""
+
+
+@dataclass(frozen=True)
+class PressureDecision:
+    """The decision plus the state the caller must carry forward."""
+
+    action: PressureAction
+    reason: str
+    usage_percentage: float
+    compacted_last_turn: bool
+    """Value the caller should store as its `_compacted_last_turn` flag."""
+
+    disable_auto_compact: bool = False
+    """Set once repeated compaction demonstrably is not freeing space.
+
+    A too-small window, or an agent that keeps re-filling context (e.g. by
+    re-reading the offloaded history to "recover" the task), makes compaction a
+    no-op — repeating it only spams the summary. The caller stops and hands
+    control back to the user instead.
+    """
+
+
+def assess_pressure(
+    usage_percentage: float,
+    *,
+    compacted_last_turn: bool = False,
+    auto_compact_enabled: bool = True,
+    context_window: int = 0,
+) -> PressureDecision:
+    """Decide how to react to ``usage_percentage`` of the model's window.
+
+    Args:
+        usage_percentage: Current usage as a percentage (0-100+).
+        compacted_last_turn: Whether the caller already auto-compacted on the
+            immediately preceding turn. If usage is still critical after that,
+            compaction is not winning and the loop is broken.
+        auto_compact_enabled: False when the caller has already disabled
+            auto-compaction for this session; it then only warns.
+        context_window: The model's window in tokens. Given, the compaction
+            point also has to leave :data:`MIN_RESERVE_TOKENS` free — see
+            :func:`compact_threshold_pct`. 0 keeps the plain percentage.
+
+    Returns:
+        A :class:`PressureDecision`. ``action`` is ``COMPACT`` only when
+        auto-compaction is enabled AND it has not already failed to help.
+    """
+    if usage_percentage >= compact_threshold_pct(context_window):
+        if not auto_compact_enabled:
+            return PressureDecision(
+                action=PressureAction.WARN,
+                reason=(
+                    f"Context critical: {usage_percentage:.0f}% — auto-compact is disabled; run "
+                    "/compact now, or /clear to start fresh."
+                ),
+                usage_percentage=usage_percentage,
+                compacted_last_turn=False,
+            )
+        if compacted_last_turn:
+            # Compaction ran last turn and we are critical again → not helping.
+            return PressureDecision(
+                action=PressureAction.WARN,
+                reason=(
+                    "Repeated auto-compaction isn't freeing space (likely a "
+                    "context-window loop). Auto-compact disabled — use /clear to "
+                    "start fresh, or switch to a larger-context model."
+                ),
+                usage_percentage=usage_percentage,
+                compacted_last_turn=False,
+                disable_auto_compact=True,
+            )
+        return PressureDecision(
+            action=PressureAction.COMPACT,
+            reason=f"Context {usage_percentage:.0f}% — auto-compacting to free space…",
+            usage_percentage=usage_percentage,
+            compacted_last_turn=True,
+        )
+
+    if usage_percentage >= CONTEXT_WARNING_THRESHOLD * 100:
+        return PressureDecision(
+            action=PressureAction.WARN,
+            reason=f"Context usage high: {usage_percentage:.0f}% — consider /compact soon.",
+            usage_percentage=usage_percentage,
+            # A compaction (if any) did free space — reset the loop guard.
+            compacted_last_turn=False,
+        )
+
+    return PressureDecision(
+        action=PressureAction.NONE,
+        reason="",
+        usage_percentage=usage_percentage,
+        compacted_last_turn=False,
+    )
+
+
+def post_compaction_still_critical(
+    usage_percentage: float, *, auto_compact_enabled: bool, context_window: int = 0
+) -> PressureDecision:
+    """Re-assess right after a compaction, to detect that it is not working.
+
+    Returns ``disable_auto_compact=True`` when usage is still at the compaction
+    threshold — the summary itself is near the window (usually a too-small
+    model), so further auto-compaction is futile.
+    """
+    decision = assess_pressure(
+        usage_percentage,
+        compacted_last_turn=False,
+        auto_compact_enabled=auto_compact_enabled,
+        context_window=context_window,
+    )
+    if decision.action is PressureAction.COMPACT:
+        return PressureDecision(
+            action=PressureAction.WARN,
+            reason=(
+                "Auto-compact couldn't free enough space (context window too small "
+                "for this conversation). Auto-compact disabled — use /clear to start "
+                "fresh or switch to a larger-context model."
+            ),
+            usage_percentage=usage_percentage,
+            compacted_last_turn=False,
+            disable_auto_compact=True,
+        )
+    return decision
+
+
+__all__ = [
+    "CONTEXT_CRITICAL_THRESHOLD",
+    "MIN_RESERVE_TOKENS",
+    "PressureAction",
+    "PressureDecision",
+    "assess_pressure",
+    "compact_threshold_pct",
+    "post_compaction_still_critical",
+]

novacode_cli/context/provider_accounting.py

@@ -0,0 +1,109 @@
+"""Supported provider preparation and content-free HTTP attempt observation."""
+
+# JSON and LangGraph interfaces carry heterogeneous values.
+# ruff: noqa: ANN401
+import json
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AttemptCounter:
+    """One dispatch's real HTTP attempts; no URLs, headers, or body retained."""
+
+    count: int = 0
+    observed: bool = False
+
+
+http_attempts: ContextVar[AttemptCounter | None] = ContextVar("nova_http_attempts", default=None)
+
+
+def _observe(request: Any) -> None:
+    del request  # Never inspect headers, body, URL, or credentials.
+    counter = http_attempts.get()
+    if counter:
+        counter.count += 1
+
+
+async def _aobserve(request: Any) -> None:
+    _observe(request)
+
+
+def instrument_http(model: Any) -> bool:
+    """Attach HTTPX hooks to supported SDK clients without changing transports."""
+    supported = False
+    for name, callback in (
+        ("root_client", _observe),
+        ("root_async_client", _aobserve),
+        ("_client", _observe),
+        ("_async_client", _aobserve),
+    ):
+        sdk = getattr(model, name, None)
+        client = getattr(sdk, "_client", None)
+        hooks = getattr(client, "event_hooks", None)
+        if isinstance(hooks, dict) and "request" in hooks:
+            if callback not in hooks["request"]:
+                hooks["request"].append(callback)
+            supported = True
+    return supported
+
+
+def prepared_request(request: Any, messages: Any, schemas: Any) -> Any:
+    """Prepare OpenAI/Anthropic payloads using their installed adapter code."""
+    model = request.model
+    # Inspect adapter ancestry before importing optional providers. Nova's
+    # gateway wrappers live in model_create but inherit the installed adapter.
+    modules = tuple(base.__module__ for base in type(model).__mro__)
+    anthropic = openai = False
+    if any(module.startswith("langchain_anthropic.") for module in modules):
+        from langchain_anthropic import ChatAnthropic
+
+        anthropic = isinstance(model, ChatAnthropic)
+    elif any(module.startswith("langchain_openai.") for module in modules):
+        from langchain_openai import ChatOpenAI
+
+        openai = isinstance(model, ChatOpenAI)
+    if not (openai or anthropic):
+        return (), None
+    prepare = getattr(model, "_get_request_payload", None)
+    if prepare is None:
+        return (), None
+    settings = dict(getattr(request, "model_settings", None) or {})
+    if schemas:
+        # The adapters' binding paths preserve built-ins and provider extras;
+        # generic schema conversion loses server search and deferred definitions.
+        settings["tools"] = model.bind_tools(request.tools).kwargs["tools"]
+    response_format = getattr(request, "response_format", None)
+    if response_format is not None:
+        from langchain.agents.structured_output import ProviderStrategy, ToolStrategy
+
+        if isinstance(response_format, ProviderStrategy) and openai:
+            settings.update(response_format.to_model_kwargs())
+        elif isinstance(response_format, ToolStrategy) and openai:
+            tools = list(settings.get("tools", []))
+            tools.extend(
+                {
+                    "type": "function",
+                    "function": {
+                        "name": spec.name,
+                        "description": spec.description or "",
+                        "parameters": spec.json_schema,
+                    },
+                }
+                for spec in response_format.schema_specs
+            )
+            settings["tools"] = tools
+        else:
+            return (), None
+    payload = prepare(messages, **settings)
+    encoded = json.dumps(payload, ensure_ascii=False, sort_keys=True, default=str)
+    reservation = next(
+        (
+            payload.get(key)
+            for key in ("max_output_tokens", "max_completion_tokens", "max_tokens")
+            if payload.get(key) is not None
+        ),
+        0,
+    )
+    return (encoded,), int(reservation)