navaia-code 1.0.50__py3-none-any.whl

navaia/api/types.py

@@ -0,0 +1,213 @@
+"""API layer types — mirrors Claude Code's message and streaming types."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Literal, Union
+from uuid import uuid4
+
+
+# ---------------------------------------------------------------------------
+# Content blocks (internal representation, provider-agnostic)
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class TextBlock:
+    text: str
+    type: Literal["text"] = "text"
+
+
+@dataclass(frozen=True)
+class ToolUseBlock:
+    name: str
+    input: dict
+    id: str = field(default_factory=lambda: f"call_{uuid4().hex[:12]}")
+    type: Literal["tool_use"] = "tool_use"
+
+
+@dataclass(frozen=True)
+class ToolResultBlock:
+    tool_use_id: str
+    content: str | list
+    is_error: bool = False
+    type: Literal["tool_result"] = "tool_result"
+
+
+@dataclass(frozen=True)
+class ThinkingBlock:
+    thinking: str
+    type: Literal["thinking"] = "thinking"
+
+
+ContentBlock = Union[TextBlock, ToolUseBlock, ToolResultBlock, ThinkingBlock]
+
+
+# ---------------------------------------------------------------------------
+# Messages (internal representation)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class UserMessage:
+    content: list[ContentBlock] | str
+    uuid: str = field(default_factory=lambda: uuid4().hex)
+    timestamp: datetime = field(default_factory=datetime.now)
+    role: Literal["user"] = "user"
+
+
+@dataclass
+class AssistantMessage:
+    content: list[ContentBlock]
+    uuid: str = field(default_factory=lambda: uuid4().hex)
+    timestamp: datetime = field(default_factory=datetime.now)
+    role: Literal["assistant"] = "assistant"
+
+
+@dataclass
+class SystemMessage:
+    text: str
+    subtype: str = "info"
+    is_api_error: bool = False
+    type: Literal["system"] = "system"
+
+
+@dataclass
+class CompactBoundaryMessage:
+    summary: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    type: Literal["compact_boundary"] = "compact_boundary"
+
+
+Message = Union[UserMessage, AssistantMessage, SystemMessage, CompactBoundaryMessage]
+
+
+# ---------------------------------------------------------------------------
+# Streaming events (yielded by the streaming layer)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class TextDeltaEvent:
+    text: str
+    type: Literal["text_delta"] = "text_delta"
+
+
+@dataclass
+class ToolCallDeltaEvent:
+    """Raw delta from the OpenAI streaming format."""
+    index: int
+    id: str | None = None
+    name: str | None = None
+    arguments_delta: str = ""
+    type: Literal["tool_call_delta"] = "tool_call_delta"
+
+
+@dataclass
+class ThinkingDeltaEvent:
+    text: str
+    type: Literal["thinking_delta"] = "thinking_delta"
+
+
+@dataclass
+class FinishEvent:
+    reason: str  # "stop", "tool_calls", "length"
+    type: Literal["finish"] = "finish"
+
+
+@dataclass
+class RetryEvent:
+    """Emitted when a retriable API error triggers a retry attempt."""
+    attempt: int
+    max_retries: int
+    delay_seconds: float
+    error_message: str
+    type: Literal["retry"] = "retry"
+
+
+@dataclass
+class UsageEvent:
+    usage: Usage
+    type: Literal["usage"] = "usage"
+
+
+StreamEvent = Union[TextDeltaEvent, ToolCallDeltaEvent, ThinkingDeltaEvent, FinishEvent, RetryEvent, UsageEvent]
+
+
+# ---------------------------------------------------------------------------
+# Usage tracking
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class Usage:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    total_tokens: int = 0
+    cost_usd: float = 0.0
+
+    def __add__(self, other: Usage) -> Usage:
+        return Usage(
+            input_tokens=self.input_tokens + other.input_tokens,
+            output_tokens=self.output_tokens + other.output_tokens,
+            total_tokens=self.total_tokens + other.total_tokens,
+            cost_usd=self.cost_usd + other.cost_usd,
+        )
+
+
+# ---------------------------------------------------------------------------
+# SDK messages (yielded by QueryEngine to the caller / UI)
+# ---------------------------------------------------------------------------
+
+class SDKMessageType(str, Enum):
+    TEXT_DELTA = "text_delta"
+    THINKING_DELTA = "thinking_delta"
+    ASSISTANT = "assistant"
+    USER = "user"
+    SYSTEM = "system"
+    TOOL_USE_START = "tool_use_start"
+    TOOL_RESULT = "tool_result"
+    COMPACT_BOUNDARY = "compact_boundary"
+    RETRY = "retry"
+    RESULT = "result"
+    PERMISSION_REQUEST = "permission_request"
+
+
+@dataclass
+class SDKMessage:
+    type: SDKMessageType
+    delta: str | None = None
+    message: Message | None = None
+    tool_name: str | None = None
+    tool_input: dict | None = None
+    tool_use_id: str | None = None
+    tool_result: str | None = None
+    is_error: bool = False
+    usage: Usage | None = None
+    cost_usd: float = 0.0
+    stop_reason: str | None = None
+    session_id: str | None = None
+    permission_future: asyncio.Future | None = None
+
+
+# ---------------------------------------------------------------------------
+# Tool call accumulator (for incremental streaming assembly)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ToolCallAccumulator:
+    id: str = ""
+    name: str = ""
+    args_str: str = ""
+
+    def to_tool_use_block(self) -> ToolUseBlock:
+        import json
+        try:
+            parsed = json.loads(self.args_str) if self.args_str else {}
+        except json.JSONDecodeError:
+            import logging
+            logging.getLogger(__name__).warning(
+                "Malformed JSON from model for tool '%s': %s",
+                self.name, self.args_str[:200],
+            )
+            parsed = {}
+        return ToolUseBlock(id=self.id, name=self.name, input=parsed)

navaia/commands/builtin/commands.py

@@ -0,0 +1,206 @@
+"""Built-in slash commands for Navaia Code."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Awaitable, Callable
+
+from navaia import __version__
+from navaia.commands.types import Command, CommandResult, CommandType
+
+
+def _build_commands() -> list[Command]:
+    """Return all built-in command definitions."""
+    return [
+        Command(
+            name="help",
+            description="List all available commands",
+            type=CommandType.LOCAL,
+            aliases=["h", "?"],
+        ),
+        Command(
+            name="clear",
+            description="Clear conversation history",
+            type=CommandType.LOCAL,
+        ),
+        Command(
+            name="exit",
+            description="Exit Navaia Code",
+            type=CommandType.LOCAL,
+            aliases=["quit", "q"],
+        ),
+        Command(
+            name="version",
+            description="Show Navaia Code version",
+            type=CommandType.LOCAL,
+            aliases=["v"],
+        ),
+        Command(
+            name="cost",
+            description="Show session cost and token usage",
+            type=CommandType.LOCAL,
+        ),
+        Command(
+            name="compact",
+            description="Compact conversation to reduce context",
+            type=CommandType.LOCAL,
+        ),
+        Command(
+            name="model",
+            description="Show or switch the current model",
+            type=CommandType.LOCAL,
+        ),
+        Command(
+            name="copy",
+            description="Copy last assistant response to clipboard",
+            type=CommandType.LOCAL,
+        ),
+        Command(
+            name="diff",
+            description="Show git diff output",
+            type=CommandType.LOCAL,
+        ),
+        Command(
+            name="vim",
+            description="Toggle vim keybinding mode",
+            type=CommandType.LOCAL,
+            is_hidden=True,
+        ),
+        Command(
+            name="think",
+            description="Enable extended thinking",
+            type=CommandType.LOCAL,
+        ),
+        Command(
+            name="plan",
+            description="Enter plan mode for structured reasoning",
+            type=CommandType.LOCAL,
+        ),
+    ]
+
+
+async def _handle_help(args: str) -> CommandResult:
+    """List all visible commands including skills."""
+    from navaia.commands.registry import get_all_commands
+
+    commands, _ = get_all_commands()
+    lines = ["Available commands:", ""]
+    for cmd in commands:
+        if cmd.is_hidden:
+            continue
+        alias_str = ""
+        if cmd.aliases:
+            alias_str = f" (aliases: {', '.join('/' + a for a in cmd.aliases)})"
+        prefix = "*" if cmd.type == CommandType.PROMPT else " "
+        lines.append(f" {prefix}/{cmd.name:<12} {cmd.description}{alias_str}")
+    lines.append("")
+    lines.append("  * = skill (sends prompt to model)")
+    lines.append("")
+    lines.append("Type any text without '/' to send a message to the model.")
+    lines.append("Add skills: create .md files in ~/.navaia/commands/")
+    return CommandResult(output="\n".join(lines))
+
+
+async def _handle_clear(_args: str) -> CommandResult:
+    return CommandResult(output="[clear]")
+
+
+async def _handle_exit(_args: str) -> CommandResult:
+    return CommandResult(output="Goodbye!", should_exit=True)
+
+
+async def _handle_version(_args: str) -> CommandResult:
+    return CommandResult(output=f"Navaia Code v{__version__}")
+
+
+async def _handle_cost(_args: str) -> CommandResult:
+    # Real handler lives in NavaiaApp._handle_cost_command (needs engine access).
+    return CommandResult(
+        output="(cost is only meaningful inside an interactive session)"
+    )
+
+
+async def _handle_compact(_args: str) -> CommandResult:
+    # IMPORTANT: This command requires engine access and is intercepted in
+    # NavaiaApp._handle_command before reaching this handler. If this stub
+    # runs, something bypassed the app-layer intercept.
+    return CommandResult(output="Error: /compact must be run from the main interface.")
+
+
+async def _handle_model(args: str) -> CommandResult:
+    # Real handler lives in NavaiaApp._handle_model_command (needs config + UI).
+    import os
+    current = os.environ.get("NAVAIA_MODEL", "(unset)")
+    if args.strip():
+        return CommandResult(
+            output=(
+                "/model only switches live in the interactive UI. "
+                f"Current model (from env): {current}"
+            )
+        )
+    return CommandResult(output=f"Current model: {current}")
+
+
+async def _handle_copy(_args: str) -> CommandResult:
+    # Handled directly in NavaiaApp._handle_command before dispatch
+    return CommandResult(output="")
+
+
+async def _handle_diff(_args: str) -> CommandResult:
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git", "diff",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+
+        if proc.returncode != 0:
+            error_msg = stderr.decode().strip() if stderr else "Unknown error"
+            return CommandResult(output=f"git diff failed: {error_msg}")
+
+        output = stdout.decode().strip() if stdout else "No changes."
+        return CommandResult(output=output)
+    except FileNotFoundError:
+        return CommandResult(output="Error: git is not installed or not in PATH.")
+
+
+async def _handle_vim(_args: str) -> CommandResult:
+    # Real handler lives in NavaiaApp._handle_vim_command.
+    return CommandResult(output="(vim mode is only toggleable inside the interactive UI)")
+
+
+async def _handle_think(_args: str) -> CommandResult:
+    # Real handler lives in NavaiaApp._handle_think_command.
+    return CommandResult(output="(thinking mode is only toggleable inside the interactive UI)")
+
+
+async def _handle_plan(_args: str) -> CommandResult:
+    # Real handler lives in NavaiaApp._handle_plan_command.
+    return CommandResult(output="(plan mode is only toggleable inside the interactive UI)")
+
+
+def _build_handlers() -> dict[str, Callable[[str], Awaitable[CommandResult]]]:
+    """Return a mapping of command name to async handler function."""
+    return {
+        "help": _handle_help,
+        "clear": _handle_clear,
+        "exit": _handle_exit,
+        "version": _handle_version,
+        "copy": _handle_copy,
+        "cost": _handle_cost,
+        "compact": _handle_compact,
+        "model": _handle_model,
+        "diff": _handle_diff,
+        "vim": _handle_vim,
+        "think": _handle_think,
+        "plan": _handle_plan,
+    }
+
+
+def get_builtin_commands() -> tuple[
+    list[Command],
+    dict[str, Callable[[str], Awaitable[CommandResult]]],
+]:
+    """Return (commands, handlers) for all built-in slash commands."""
+    return _build_commands(), _build_handlers()

navaia/commands/dispatcher.py

@@ -0,0 +1,38 @@
+"""Dispatch slash commands to their handlers."""
+
+from __future__ import annotations
+
+from typing import Awaitable, Callable
+
+from .parser import is_slash_command, parse_slash_command
+from .registry import find_command
+from .types import Command, CommandResult
+
+
+async def process_user_input(
+    text: str,
+    commands: list[Command],
+    handlers: dict[str, Callable[[str], Awaitable[CommandResult]]],
+) -> CommandResult:
+    """Process user input, dispatching slash commands or passing through text.
+
+    If the input is a slash command, look up the matching command and invoke
+    its handler. Otherwise, return the raw text marked for model query.
+    """
+    if not is_slash_command(text):
+        return CommandResult(output=text, should_query=True)
+
+    name, args = parse_slash_command(text)
+    command = find_command(name, commands)
+
+    if command is None:
+        available = ", ".join(f"/{c.name}" for c in commands if not c.is_hidden)
+        return CommandResult(
+            output=f"Unknown command: /{name}\nAvailable commands: {available}"
+        )
+
+    handler = handlers.get(command.name)
+    if handler is None:
+        return CommandResult(output=f"No handler registered for /{command.name}")
+
+    return await handler(args)

navaia/commands/parser.py

@@ -0,0 +1,25 @@
+"""Parse slash commands from user input."""
+
+
+def is_slash_command(text: str) -> bool:
+    """Check if text is a slash command (starts with '/' followed by a letter)."""
+    stripped = text.strip()
+    return len(stripped) >= 2 and stripped[0] == "/" and stripped[1].isalpha()
+
+
+def parse_slash_command(text: str) -> tuple[str, str]:
+    """Parse a slash command into (command_name, arguments).
+
+    Examples:
+        "/search foo bar" -> ("search", "foo bar")
+        "/help"           -> ("help", "")
+        "/model gpt-4"    -> ("model", "gpt-4")
+    """
+    stripped = text.strip()
+    without_slash = stripped[1:]
+
+    parts = without_slash.split(maxsplit=1)
+    command_name = parts[0].lower()
+    args = parts[1] if len(parts) > 1 else ""
+
+    return command_name, args

navaia/commands/registry.py

@@ -0,0 +1,48 @@
+"""Command registry — merges built-in and skill commands."""
+
+from __future__ import annotations
+
+import os
+from typing import Awaitable, Callable
+
+from .builtin.commands import get_builtin_commands
+from .skills import get_skill_commands
+from .types import Command, CommandResult
+
+
+def get_all_commands(
+    cwd: str | None = None,
+) -> tuple[
+    list[Command],
+    dict[str, Callable[[str], Awaitable[CommandResult]]],
+]:
+    """Return merged (commands, handlers) from built-in + skills.
+
+    Skills discovered from ~/.navaia/commands/ and <cwd>/.navaia/commands/.
+    Built-in commands take precedence over skills with the same name.
+    """
+    commands, handlers = get_builtin_commands()
+    builtin_names = {c.name for c in commands}
+
+    skill_cmds, skill_handlers = get_skill_commands(cwd or os.getcwd())
+
+    # Merge skills, skipping any that conflict with built-ins
+    for cmd in skill_cmds:
+        if cmd.name not in builtin_names:
+            commands.append(cmd)
+    for name, handler in skill_handlers.items():
+        if name not in handlers:
+            handlers[name] = handler
+
+    return commands, handlers
+
+
+def find_command(name: str, commands: list[Command]) -> Command | None:
+    """Find a command by name or alias. Returns None if not found."""
+    lower_name = name.lower()
+    for cmd in commands:
+        if cmd.name == lower_name:
+            return cmd
+        if lower_name in cmd.aliases:
+            return cmd
+    return None

navaia/commands/skills.py

@@ -0,0 +1,150 @@
+"""Skill loader — discovers and loads user-defined slash commands from .md files.
+
+Skills are markdown files with optional YAML frontmatter.  Navaia Code
+searches four directories in priority order (later overrides earlier):
+
+  1. ~/.claude/commands/         (Claude Code user-global — full compatibility)
+  2. ~/.navaia/commands/         (Navaia user-global)
+  3. <cwd>/.claude/commands/     (Claude Code project-local)
+  4. <cwd>/.navaia/commands/     (Navaia project-local — highest priority)
+
+This means any skill you install or create for Claude Code works in Navaia
+Code automatically.  Skills from the internet, community repos, or your own
+``~/.claude/commands/`` folder are picked up with zero extra setup.
+
+Each file's stem becomes the command name (e.g. ``commit.md`` → ``/commit``).
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Awaitable, Callable
+
+from navaia.commands.types import Command, CommandResult, CommandType
+
+_FRONTMATTER_RE = re.compile(
+    r"^---\s*\n(.*?)\n---\s*\n",
+    re.DOTALL,
+)
+
+_DESC_RE = re.compile(r"^description:\s*(.+)$", re.MULTILINE)
+
+
+@dataclass(frozen=True)
+class SkillDefinition:
+    """Parsed skill file."""
+
+    name: str
+    description: str
+    body: str
+    source_path: Path
+
+
+def _parse_skill_file(path: Path) -> SkillDefinition | None:
+    """Parse a skill markdown file. Returns None on failure."""
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    name = path.stem
+
+    # Extract frontmatter
+    fm_match = _FRONTMATTER_RE.match(raw)
+    if fm_match:
+        frontmatter = fm_match.group(1)
+        body = raw[fm_match.end():]
+    else:
+        # No frontmatter — use whole file as body
+        frontmatter = ""
+        body = raw
+
+    # Extract description from frontmatter
+    desc_match = _DESC_RE.search(frontmatter)
+    description = desc_match.group(1).strip().strip("\"'") if desc_match else f"Skill: {name}"
+
+    return SkillDefinition(
+        name=name,
+        description=description,
+        body=body.strip(),
+        source_path=path,
+    )
+
+
+def _scan_dir(directory: Path, into: dict[str, SkillDefinition]) -> None:
+    """Scan *directory* for ``.md`` skill files, merging into *into*."""
+    if not directory.is_dir():
+        return
+    for md_file in sorted(directory.glob("*.md")):
+        skill = _parse_skill_file(md_file)
+        if skill:
+            into[skill.name] = skill  # later dirs override earlier
+
+
+def discover_skills(cwd: str | None = None) -> list[SkillDefinition]:
+    """Discover skill files from all known locations.
+
+    Search order (later overrides earlier):
+      1. ~/.claude/commands/       — Claude Code user-global
+      2. ~/.navaia/commands/       — Navaia user-global
+      3. <cwd>/.claude/commands/   — Claude Code project-local
+      4. <cwd>/.navaia/commands/   — Navaia project-local
+    """
+    skills: dict[str, SkillDefinition] = {}
+    home = Path.home()
+
+    # User-global directories
+    _scan_dir(home / ".claude" / "commands", skills)
+    _scan_dir(home / ".navaia" / "commands", skills)
+
+    # Project-local directories
+    if cwd:
+        cwd_path = Path(cwd)
+        _scan_dir(cwd_path / ".claude" / "commands", skills)
+        _scan_dir(cwd_path / ".navaia" / "commands", skills)
+
+    return list(skills.values())
+
+
+def _make_skill_handler(
+    skill: SkillDefinition,
+) -> Callable[[str], Awaitable[CommandResult]]:
+    """Create an async handler that returns the skill body as a prompt."""
+
+    async def handler(args: str) -> CommandResult:
+        # The skill body is injected as a prompt to the model
+        prompt_text = skill.body
+        if args.strip():
+            prompt_text = f"{prompt_text}\n\nUser arguments: {args.strip()}"
+        return CommandResult(output=prompt_text, should_query=True)
+
+    return handler
+
+
+def get_skill_commands(
+    cwd: str | None = None,
+) -> tuple[
+    list[Command],
+    dict[str, Callable[[str], Awaitable[CommandResult]]],
+]:
+    """Return (commands, handlers) for all discovered skills.
+
+    Each skill becomes a slash command that, when invoked, sends its
+    markdown body as a prompt to the model (should_query=True).
+    """
+    skills = discover_skills(cwd)
+    commands: list[Command] = []
+    handlers: dict[str, Callable[[str], Awaitable[CommandResult]]] = {}
+
+    for skill in skills:
+        cmd = Command(
+            name=skill.name,
+            description=skill.description,
+            type=CommandType.PROMPT,
+        )
+        commands.append(cmd)
+        handlers[skill.name] = _make_skill_handler(skill)
+
+    return commands, handlers