navaia-code 1.0.50__py3-none-any.whl

navaia/commands/types.py

@@ -0,0 +1,26 @@
+"""Command types for the slash commands system."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class CommandType(str, Enum):
+    LOCAL = "local"
+    PROMPT = "prompt"
+    WIDGET = "widget"
+
+
+@dataclass(frozen=True)
+class Command:
+    name: str
+    description: str
+    type: CommandType
+    aliases: list[str] = field(default_factory=list)
+    is_hidden: bool = False
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    output: str = ""
+    should_query: bool = False
+    should_exit: bool = False

navaia/compact/compact.py

@@ -0,0 +1,241 @@
+"""Main compaction logic — summarizes long conversations to reclaim context."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from openai import AsyncOpenAI
+
+from navaia.api.types import (
+    AssistantMessage,
+    CompactBoundaryMessage,
+    ContentBlock,
+    Message,
+    SystemMessage,
+    TextBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+    UserMessage,
+)
+from navaia.compact.prompt import BASE_COMPACT_PROMPT
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+COMPACT_THRESHOLD = 0.85  # 85% of context window
+
+_MODEL_CONTEXT_WINDOWS: dict[str, int] = {
+    "claude-3-opus-20240229": 200_000,
+    "claude-3-5-sonnet-20241022": 200_000,
+    "claude-3-haiku-20240307": 200_000,
+    "claude-sonnet-4-20250514": 200_000,
+    "claude-opus-4-20250514": 200_000,
+    "gpt-4o": 128_000,
+    "gpt-4-turbo": 128_000,
+    "gpt-4": 8_192,
+    "gpt-3.5-turbo": 16_385,
+}
+
+DEFAULT_CONTEXT_WINDOW = 128_000
+
+
+# ---------------------------------------------------------------------------
+# Result type
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class CompactResult:
+    """Immutable result of a compaction operation."""
+
+    messages: list[Message]
+    summary: str
+
+
+# ---------------------------------------------------------------------------
+# Token estimation
+# ---------------------------------------------------------------------------
+
+def estimate_tokens(messages: list[Message]) -> int:
+    """Rough token count — approximately 4 characters per token."""
+    total_chars = 0
+    for msg in messages:
+        total_chars += _message_char_count(msg)
+    return total_chars // 4
+
+
+def _message_char_count(msg: Message) -> int:
+    """Count characters in a single message."""
+    if isinstance(msg, UserMessage):
+        return _content_char_count(msg.content)
+    if isinstance(msg, AssistantMessage):
+        return _content_char_count(msg.content)
+    if isinstance(msg, SystemMessage):
+        return len(msg.text)
+    if isinstance(msg, CompactBoundaryMessage):
+        return len(msg.summary)
+    return 0
+
+
+def _content_char_count(content: list[ContentBlock] | str) -> int:
+    """Count characters in message content."""
+    if isinstance(content, str):
+        return len(content)
+    total = 0
+    for block in content:
+        if isinstance(block, TextBlock):
+            total += len(block.text)
+        elif isinstance(block, ToolUseBlock):
+            total += len(block.name) + len(str(block.input))
+        elif isinstance(block, ToolResultBlock):
+            if isinstance(block.content, str):
+                total += len(block.content)
+            else:
+                total += len(str(block.content))
+        else:
+            # ThinkingBlock or unknown
+            total += len(str(getattr(block, "thinking", "")))
+    return total
+
+
+# ---------------------------------------------------------------------------
+# Context window lookup
+# ---------------------------------------------------------------------------
+
+def get_model_context_window(model: str) -> int:
+    """Return the context window size for a model, defaulting to 128k."""
+    # Check exact match first
+    if model in _MODEL_CONTEXT_WINDOWS:
+        return _MODEL_CONTEXT_WINDOWS[model]
+    # Check if the model name contains a known key (e.g. "openai/gpt-4o")
+    for known_model, window in _MODEL_CONTEXT_WINDOWS.items():
+        if known_model in model:
+            return window
+    return DEFAULT_CONTEXT_WINDOW
+
+
+# ---------------------------------------------------------------------------
+# Auto-compact check
+# ---------------------------------------------------------------------------
+
+def should_auto_compact(messages: list[Message], model: str) -> bool:
+    """Return True when estimated tokens exceed the compaction threshold."""
+    if not messages:
+        return False
+    context_window = get_model_context_window(model)
+    token_estimate = estimate_tokens(messages)
+    return token_estimate >= int(context_window * COMPACT_THRESHOLD)
+
+
+# ---------------------------------------------------------------------------
+# Message formatting
+# ---------------------------------------------------------------------------
+
+def format_messages_for_compact(messages: list[Message]) -> str:
+    """Format conversation messages as plain text for the summarization prompt.
+
+    Images and binary content are stripped; only text is preserved.
+    """
+    parts: list[str] = []
+    for msg in messages:
+        formatted = _format_single_message(msg)
+        if formatted:
+            parts.append(formatted)
+    return "\n\n".join(parts)
+
+
+def _format_single_message(msg: Message) -> str:
+    """Format one message as a labeled text block."""
+    if isinstance(msg, UserMessage):
+        body = _content_to_text(msg.content)
+        return f"[User]\n{body}"
+    if isinstance(msg, AssistantMessage):
+        body = _content_to_text(msg.content)
+        return f"[Assistant]\n{body}"
+    if isinstance(msg, SystemMessage):
+        return f"[System ({msg.subtype})]\n{msg.text}"
+    if isinstance(msg, CompactBoundaryMessage):
+        return f"[Previous Summary]\n{msg.summary}"
+    return ""
+
+
+def _content_to_text(content: list[ContentBlock] | str) -> str:
+    """Extract text from message content, stripping images."""
+    if isinstance(content, str):
+        return content
+    parts: list[str] = []
+    for block in content:
+        if isinstance(block, TextBlock):
+            parts.append(block.text)
+        elif isinstance(block, ToolUseBlock):
+            parts.append(f"[Tool call: {block.name}({_truncate(str(block.input), 500)})]")
+        elif isinstance(block, ToolResultBlock):
+            result_text = block.content if isinstance(block.content, str) else str(block.content)
+            prefix = "[Tool error]" if block.is_error else "[Tool result]"
+            parts.append(f"{prefix} {_truncate(result_text, 1000)}")
+        # ThinkingBlock and unknown blocks are intentionally skipped
+    return "\n".join(parts)
+
+
+def _truncate(text: str, max_len: int) -> str:
+    """Truncate text with an ellipsis if it exceeds max_len."""
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 3] + "..."
+
+
+# ---------------------------------------------------------------------------
+# Summary extraction
+# ---------------------------------------------------------------------------
+
+def extract_summary_block(raw: str) -> str:
+    """Extract content between <summary> tags from model output.
+
+    Returns the raw text if no tags are found (graceful fallback).
+    """
+    match = re.search(r"<summary>(.*?)</summary>", raw, re.DOTALL)
+    if match:
+        return match.group(1).strip()
+    return raw.strip()
+
+
+# ---------------------------------------------------------------------------
+# Main compaction pipeline
+# ---------------------------------------------------------------------------
+
+async def compact_conversation(
+    messages: list[Message],
+    client: AsyncOpenAI,
+    model: str,
+) -> CompactResult:
+    """Summarize the conversation and return a compacted message list.
+
+    Pipeline:
+    1. Format messages as plain text (strip images, binary data).
+    2. Call model with BASE_COMPACT_PROMPT to produce a summary.
+    3. Extract the <summary> block from the response.
+    4. Return a CompactResult with a single CompactBoundaryMessage.
+    """
+    formatted_text = format_messages_for_compact(messages)
+
+    prompt_content = (
+        f"{BASE_COMPACT_PROMPT}\n\n"
+        f"---\nConversation to summarize:\n---\n\n"
+        f"{formatted_text}"
+    )
+
+    response = await client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt_content}],
+        temperature=0.0,
+        max_tokens=8192,
+    )
+
+    raw_output = response.choices[0].message.content or ""
+    summary = extract_summary_block(raw_output)
+
+    boundary = CompactBoundaryMessage(summary=summary)
+    compacted_messages: list[Message] = [boundary]
+
+    return CompactResult(messages=compacted_messages, summary=summary)

navaia/compact/prompt.py

@@ -0,0 +1,22 @@
+"""Compaction prompt template for conversation summarization."""
+
+BASE_COMPACT_PROMPT = """
+Your task is to create a detailed summary of the conversation so far.
+This summary will replace the conversation for context window management.
+
+Structure the summary as follows:
+
+1. Primary Request and Intent — what the user asked for, their goals
+2. Key Technical Concepts — technologies, patterns, decisions made
+3. Files and Code Sections — important files with snippets and why they matter
+4. Errors and Fixes — problems encountered and how they were resolved
+5. Problem Solving — approaches tried and outcomes
+6. All User Messages — every user message verbatim (not tool results)
+7. Pending Tasks — incomplete work, todos
+8. Current Work — most recent work with file names and relevant code
+9. Optional Next Step — direct quote from user's latest intent
+
+Wrap your analysis in <analysis> tags.
+Wrap the final summary in <summary> tags.
+Be thorough — this summary is the ONLY context the next turn will have.
+"""

navaia/compact/restore.py

@@ -0,0 +1,91 @@
+"""Post-compact restoration — re-injects recent file context after compaction."""
+
+from __future__ import annotations
+
+from navaia.api.types import (
+    AssistantMessage,
+    ContentBlock,
+    Message,
+    TextBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+    UserMessage,
+)
+
+
+def restore_recent_files(messages: list[Message], max_files: int = 5) -> list[Message]:
+    """Extract the last N file-read results from pre-compact messages.
+
+    Scans messages in reverse to find tool results that look like file reads
+    (tool_use blocks named "Read", "read_file", etc.) and returns them as
+    synthetic UserMessage entries to append after the compact boundary so the
+    model retains recent file context.
+    """
+    _READ_TOOL_NAMES = frozenset({"Read", "read_file", "ReadFile", "read"})
+
+    file_read_pairs: list[Message] = []
+    seen_files: set[str] = set()
+
+    for msg in reversed(messages):
+        if len(file_read_pairs) >= max_files * 2:
+            break
+        if not isinstance(msg, (UserMessage, AssistantMessage)):
+            continue
+
+        content = msg.content
+        if isinstance(content, str):
+            continue
+
+        for block in content:
+            if len(seen_files) >= max_files:
+                break
+            if isinstance(block, ToolUseBlock) and block.name in _READ_TOOL_NAMES:
+                file_path = _extract_file_path(block.input)
+                if file_path and file_path not in seen_files:
+                    result_block = _find_result_for_tool(messages, block.id)
+                    if result_block is not None:
+                        seen_files.add(file_path)
+                        file_read_pairs.append(
+                            UserMessage(
+                                content=[
+                                    TextBlock(
+                                        text=(
+                                            f"[Restored file context: {file_path}]\n"
+                                            f"{_result_to_text(result_block)}"
+                                        )
+                                    )
+                                ]
+                            )
+                        )
+
+    # Reverse to restore chronological order
+    file_read_pairs.reverse()
+    return file_read_pairs
+
+
+def _extract_file_path(tool_input: dict) -> str | None:
+    """Pull the file path from a Read tool's input dict."""
+    for key in ("file_path", "path", "filePath", "filename"):
+        value = tool_input.get(key)
+        if isinstance(value, str) and value:
+            return value
+    return None
+
+
+def _find_result_for_tool(messages: list[Message], tool_use_id: str) -> ToolResultBlock | None:
+    """Find the ToolResultBlock matching a given tool_use_id."""
+    for msg in messages:
+        content: list[ContentBlock] | str = getattr(msg, "content", "")
+        if isinstance(content, str):
+            continue
+        for block in content:
+            if isinstance(block, ToolResultBlock) and block.tool_use_id == tool_use_id:
+                return block
+    return None
+
+
+def _result_to_text(block: ToolResultBlock) -> str:
+    """Convert a ToolResultBlock's content to plain text."""
+    if isinstance(block.content, str):
+        return block.content
+    return str(block.content)

navaia/config/env.py

@@ -0,0 +1,53 @@
+"""Environment variable overrides for Navaia settings.
+
+Any ``NAVAIA_*`` variable is mapped to the corresponding Settings field:
+
+    NAVAIA_MODEL          -> default_model
+    NAVAIA_VERBOSE        -> verbose  (truthy: "1", "true", "yes")
+    NAVAIA_THEME          -> theme
+    NAVAIA_VIM_MODE       -> vim_mode (truthy: "1", "true", "yes")
+    NAVAIA_MAX_THINKING   -> max_thinking_tokens
+    NAVAIA_THINKING       -> always_thinking_enabled (truthy)
+"""
+
+import os
+
+_TRUTHY = frozenset({"1", "true", "yes"})
+
+# Mapping: env var name -> (settings key, coerce function)
+_ENV_MAP: dict[str, tuple[str, type]] = {
+    "NAVAIA_PROVIDER": ("provider", str),
+    "NAVAIA_MODEL": ("default_model", str),
+    "NAVAIA_VERBOSE": ("verbose", lambda v: v.lower() in _TRUTHY),
+    "NAVAIA_THEME": ("theme", str),
+    "NAVAIA_VIM_MODE": ("vim_mode", lambda v: v.lower() in _TRUTHY),
+    "NAVAIA_MAX_THINKING": ("max_thinking_tokens", int),
+    "NAVAIA_THINKING": (
+        "always_thinking_enabled",
+        lambda v: v.lower() in _TRUTHY,
+    ),
+}
+
+
+def get_env_overrides() -> dict:
+    """Read NAVAIA_* environment variables and return as a dict.
+
+    Only variables that are actually set in the environment are included.
+    Invalid values (e.g. non-numeric for max_thinking_tokens) are silently
+    skipped so a single bad variable does not prevent startup.
+    """
+    overrides: dict = {}
+    for env_var, (settings_key, coerce) in _ENV_MAP.items():
+        raw = os.environ.get(env_var)
+        if raw is None:
+            continue
+        try:
+            overrides[settings_key] = coerce(raw)
+        except (ValueError, TypeError):
+            # Skip malformed values rather than crashing at startup
+            import logging
+
+            logging.getLogger(__name__).warning(
+                "Ignoring invalid value for %s: %r", env_var, raw
+            )
+    return overrides

navaia/config/global_config.py

@@ -0,0 +1,43 @@
+"""Global configuration at ~/.navaia/."""
+
+from pathlib import Path
+import json
+
+
+def get_navaia_home() -> Path:
+    """Return ~/.navaia/ directory, creating if needed."""
+    home = Path.home() / ".navaia"
+    home.mkdir(parents=True, exist_ok=True)
+    return home
+
+
+def load_global_config() -> dict:
+    """Load ~/.navaia/config.json.
+
+    Returns an empty dict if the file does not exist or contains
+    invalid JSON.
+    """
+    path = get_navaia_home() / "config.json"
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as exc:
+        # Log but don't crash — fall back to defaults
+        import logging
+
+        logging.getLogger(__name__).warning(
+            "Failed to read global config at %s: %s", path, exc
+        )
+        return {}
+
+
+def save_global_config(config: dict) -> None:
+    """Save to ~/.navaia/config.json.
+
+    Creates the parent directory if it does not exist.
+    """
+    if not isinstance(config, dict):
+        raise TypeError("config must be a dict")
+    path = get_navaia_home() / "config.json"
+    path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")

navaia/config/project_config.py

@@ -0,0 +1,53 @@
+"""Per-project configuration at .navaia/ (falls back to .claude/ for compatibility)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def find_git_root(cwd: str) -> str | None:
+    """Walk up from *cwd* to find the nearest git root directory.
+
+    Returns the absolute path as a string, or None if no git root is
+    found before reaching the filesystem root.
+    """
+    current = Path(cwd).resolve()
+    while True:
+        if (current / ".git").exists():
+            return str(current)
+        parent = current.parent
+        if parent == current:
+            # Reached filesystem root
+            return None
+        current = parent
+
+
+def load_project_config(cwd: str) -> dict:
+    """Load project config from .navaia/config.json (or .claude/config.json fallback).
+
+    Searches for the git root first; if found, looks for
+    ``<git_root>/.navaia/config.json`` then ``<git_root>/.claude/config.json``.
+    Falls back to ``<cwd>/`` when there is no git root.
+
+    Returns an empty dict when no config file is found or unreadable.
+    """
+    root = find_git_root(cwd)
+    base = Path(root) if root else Path(cwd)
+
+    # Try .navaia first, then .claude for backwards compatibility
+    for config_dir in [".navaia", ".claude"]:
+        config_path = base / config_dir / "config.json"
+        if config_path.exists():
+            try:
+                return json.loads(config_path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError) as exc:
+                logger.warning(
+                    "Failed to read project config at %s: %s", config_path, exc
+                )
+                return {}
+
+    return {}