nexcoder 0.1.0__py3-none-any.whl

nex/config.py

@@ -0,0 +1,168 @@
+"""Configuration management for Nex AI.
+
+Settings are loaded from three sources in order of priority:
+1. Environment variables (highest priority)
+2. Project-level config: .nex/config.toml
+3. Global config: ~/.config/nex/config.toml (lowest priority)
+"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+from nex.exceptions import ConfigError
+
+console = Console(stderr=True)
+
+_GLOBAL_CONFIG_DIR = Path.home() / ".config" / "nex"
+_GLOBAL_CONFIG_PATH = _GLOBAL_CONFIG_DIR / "config.toml"
+
+
+@dataclass
+class NexConfig:
+    """Nex AI configuration.
+
+    Attributes:
+        api_key: Anthropic API key.
+        model: Default model for code generation and reasoning.
+        haiku_model: Model for planning and lightweight tasks.
+        max_iterations: Maximum tool calls per task.
+        dry_run: If True, show planned actions without executing.
+        log_level: Logging verbosity (DEBUG, INFO, WARNING, ERROR).
+        nex_dir: Path to the .nex directory (relative to project root).
+        test_command: Override for auto-detected test command (empty = auto-detect).
+        test_timeout: Maximum seconds to wait for test suite to complete.
+    """
+
+    project_dir: Path = field(default_factory=Path.cwd)
+    api_key: str = ""
+    model: str = "claude-sonnet-4-20250514"
+    haiku_model: str = "claude-haiku-4-5-20251001"
+    max_iterations: int = 25
+    dry_run: bool = False
+    log_level: str = "INFO"
+    nex_dir: Path = field(default_factory=lambda: Path(".nex"))
+    test_command: str = ""
+    test_timeout: int = 120
+
+
+def load_config(project_dir: Path) -> NexConfig:
+    """Load configuration from env vars, project config, and global config.
+
+    Priority: env vars > .nex/config.toml > ~/.config/nex/config.toml
+
+    Args:
+        project_dir: Root directory of the project.
+
+    Returns:
+        A fully resolved NexConfig instance.
+
+    Raises:
+        ConfigError: If the API key is not set anywhere.
+    """
+    config = NexConfig(project_dir=project_dir)
+
+    # Layer 1: Global config (lowest priority)
+    global_settings = _load_toml(_GLOBAL_CONFIG_PATH)
+    _apply_toml(config, global_settings)
+
+    # Layer 2: Project config
+    project_config_path = project_dir / ".nex" / "config.toml"
+    project_settings = _load_toml(project_config_path)
+    _apply_toml(config, project_settings)
+
+    # Layer 3: Environment variables (highest priority)
+    _apply_env(config)
+
+    return config
+
+
+def ensure_api_key(config: NexConfig) -> None:
+    """Validate that an API key is configured.
+
+    Args:
+        config: The configuration to validate.
+
+    Raises:
+        ConfigError: If api_key is empty.
+    """
+    if not config.api_key:
+        raise ConfigError(
+            "Anthropic API key not found. Set ANTHROPIC_API_KEY environment variable "
+            "or run 'nex auth' to configure it."
+        )
+
+
+def save_global_config(key: str, value: str) -> None:
+    """Save a key-value pair to the global config file.
+
+    Args:
+        key: Configuration key (e.g. "api_key").
+        value: Configuration value.
+    """
+    _GLOBAL_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    settings: dict[str, Any] = {}
+    if _GLOBAL_CONFIG_PATH.is_file():
+        settings = _load_toml(_GLOBAL_CONFIG_PATH)
+
+    settings[key] = value
+
+    lines = [f'{k} = "{v}"' for k, v in settings.items()]
+    _GLOBAL_CONFIG_PATH.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    console.print(f"[green]Saved[/green] {key} to {_GLOBAL_CONFIG_PATH}")
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    """Load a TOML file, returning an empty dict if missing or invalid."""
+    if not path.is_file():
+        return {}
+    try:
+        return tomllib.loads(path.read_text(encoding="utf-8"))
+    except (tomllib.TOMLDecodeError, OSError) as exc:
+        console.print(f"[yellow]Warning:[/yellow] Could not parse {path}: {exc}")
+        return {}
+
+
+def _apply_toml(config: NexConfig, settings: dict[str, Any]) -> None:
+    """Merge TOML settings into a NexConfig (only set non-empty values)."""
+    if "api_key" in settings:
+        config.api_key = str(settings["api_key"])
+    if "model" in settings:
+        config.model = str(settings["model"])
+    if "haiku_model" in settings:
+        config.haiku_model = str(settings["haiku_model"])
+    if "max_iterations" in settings:
+        config.max_iterations = int(settings["max_iterations"])
+    if "dry_run" in settings:
+        config.dry_run = bool(settings["dry_run"])
+    if "log_level" in settings:
+        config.log_level = str(settings["log_level"]).upper()
+    if "test_command" in settings:
+        config.test_command = str(settings["test_command"])
+    if "test_timeout" in settings:
+        config.test_timeout = int(settings["test_timeout"])
+
+
+def _apply_env(config: NexConfig) -> None:
+    """Override config with environment variables where set."""
+    if api_key := os.environ.get("ANTHROPIC_API_KEY"):
+        config.api_key = api_key
+    if model := os.environ.get("NEX_MODEL"):
+        config.model = model
+    if max_iter := os.environ.get("NEX_MAX_ITERATIONS"):
+        config.max_iterations = int(max_iter)
+    if dry_run := os.environ.get("NEX_DRY_RUN"):
+        config.dry_run = dry_run.lower() in ("true", "1", "yes")
+    if log_level := os.environ.get("NEX_LOG_LEVEL"):
+        config.log_level = log_level.upper()
+    if test_cmd := os.environ.get("NEX_TEST_COMMAND"):
+        config.test_command = test_cmd
+    if test_timeout := os.environ.get("NEX_TEST_TIMEOUT"):
+        config.test_timeout = int(test_timeout)

nex/context.py

@@ -0,0 +1,252 @@
+"""Context assembly for API calls with priority-based token budgeting."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+
+from nex.indexer.index import CodeIndex, IndexBuilder
+from nex.memory.errors import ErrorPattern
+
+console = Console(stderr=True)
+
+_COMMENT_PREFIXES = ("#", "//", "/*", "*", '"""', "'''")
+
+_SYSTEM_PROMPT_TEMPLATE = """\
+You are Nex, an AI coding agent that works on the user's codebase. You have access to tools \
+for reading files, writing files, running commands, searching code, and listing directories.
+
+## Project Context
+{project_memory}
+
+## Past Errors to Avoid
+{error_patterns}
+
+## Relevant Code
+{relevant_code}
+
+## Rules
+- Always read existing code before modifying it. Match the project's style.
+- Run tests after making changes. If tests fail, fix them before reporting success.
+- Never execute destructive commands without user approval.
+- When you make an architectural decision, explain why briefly.
+- If you're unsure about something, ask the user rather than guessing.
+- Keep changes minimal — don't refactor code that isn't related to the task.
+"""
+
+
+class ContextAssembler:
+    """Assembles the context window for API calls with priority-based budgeting.
+
+    Token budget: 150K of 200K window reserved for context, 50K for response.
+    Priority order: system prompt -> project memory -> error patterns -> relevant code.
+    """
+
+    TOKEN_BUDGET = 150_000
+
+    def __init__(self, project_dir: Path) -> None:
+        """Initialize the context assembler.
+
+        Args:
+            project_dir: Project root directory.
+        """
+        self._project_dir = project_dir
+
+    def build_system_prompt(
+        self,
+        project_memory: str,
+        error_patterns: list[ErrorPattern],
+        relevant_code: list[tuple[str, str]],
+    ) -> str:
+        """Assemble the system prompt from all context sources.
+
+        Args:
+            project_memory: Contents of .nex/memory.md.
+            error_patterns: Recent similar error patterns.
+            relevant_code: (file_path, content) pairs of relevant code.
+
+        Returns:
+            The assembled system prompt string.
+        """
+        # Format error patterns
+        if error_patterns:
+            error_text = "\n".join(
+                f"- [{ep.error_type}] {ep.what_failed} -> Fix: {ep.what_fixed}"
+                + (f" (in {ep.file_path})" if ep.file_path else "")
+                for ep in error_patterns
+            )
+        else:
+            error_text = "No relevant past errors found."
+
+        # Format relevant code
+        if relevant_code:
+            code_sections = []
+            for file_path, content in relevant_code:
+                code_sections.append(f"### {file_path}\n```\n{content}\n```")
+            code_text = "\n\n".join(code_sections)
+        else:
+            code_text = "No relevant code indexed yet."
+
+        return _SYSTEM_PROMPT_TEMPLATE.format(
+            project_memory=project_memory or "No project memory found. Run 'nex init' first.",
+            error_patterns=error_text,
+            relevant_code=code_text,
+        )
+
+    def select_relevant_code(
+        self,
+        task: str,
+        index: CodeIndex | None,
+        budget_tokens: int = 100_000,
+    ) -> list[tuple[str, str]]:
+        """Select relevant code files based on task description.
+
+        Uses file-level TF-IDF relevance scoring from the index. Applies a
+        relevance threshold to filter noise. Two-phase budget: 60% for full
+        file content, 40% for signature-only summaries of remaining files.
+
+        Args:
+            task: The user's task description.
+            index: Pre-loaded code index.
+            budget_tokens: Maximum tokens worth of code to include.
+
+        Returns:
+            List of (file_path, content) pairs.
+        """
+        if index is None:
+            return []
+
+        builder = IndexBuilder(self._project_dir)
+        try:
+            ranked_files = builder.search_files(task, index)
+        except Exception:
+            return []
+
+        if not ranked_files:
+            return []
+
+        # Apply relevance threshold
+        top_score = ranked_files[0][1]
+        threshold = self._relevance_threshold(top_score)
+        ranked_files = [(fp, sc) for fp, sc in ranked_files if sc >= threshold]
+
+        # Two-phase budget: 60% full content, 40% signature summaries
+        full_budget = int(budget_tokens * 0.60)
+        sig_budget = budget_tokens - full_budget
+
+        results: list[tuple[str, str]] = []
+        tokens_used = 0
+        remaining_files: list[str] = []
+
+        # Phase 1: Full file content
+        for file_path, _score in ranked_files:
+            abs_path = self._project_dir / file_path
+            if not abs_path.is_file():
+                continue
+
+            try:
+                content = abs_path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+
+            file_tokens = self.estimate_tokens(content)
+            if tokens_used + file_tokens <= full_budget:
+                results.append((file_path, content))
+                tokens_used += file_tokens
+                continue
+
+            # Try truncation (first 200 lines)
+            lines = content.splitlines()[:200]
+            truncated = "\n".join(lines) + "\n... (truncated)"
+            trunc_tokens = self.estimate_tokens(truncated)
+            if tokens_used + trunc_tokens <= full_budget:
+                results.append((file_path, truncated))
+                tokens_used += trunc_tokens
+                continue
+
+            # Defer to signature phase
+            remaining_files.append(file_path)
+
+        # Phase 2: Signature-only summaries for remaining files
+        sig_tokens_used = 0
+        for file_path in remaining_files:
+            sig_text = self._extract_signatures(file_path, builder, index)
+            if not sig_text:
+                continue
+
+            sig_tokens = self.estimate_tokens(sig_text)
+            if sig_tokens_used + sig_tokens > sig_budget:
+                break
+
+            results.append((file_path, f"(signatures only)\n{sig_text}"))
+            sig_tokens_used += sig_tokens
+
+        return results
+
+    @staticmethod
+    def estimate_tokens(text: str) -> int:
+        """Estimate token count with code/comment-aware heuristic.
+
+        Code lines average ~3.5 chars/token due to variable names and syntax.
+        Comment/docstring lines average ~4.5 chars/token (more natural language).
+
+        Args:
+            text: Input text.
+
+        Returns:
+            Estimated number of tokens.
+        """
+        if not text:
+            return 0
+
+        total = 0
+        for line in text.splitlines():
+            stripped = line.lstrip()
+            length = len(line)
+            if not stripped:
+                total += 1  # blank line ≈ 1 token
+            elif stripped.startswith(_COMMENT_PREFIXES):
+                total += max(1, int(length / 4.5))
+            else:
+                total += max(1, int(length / 3.5))
+        return total
+
+    @staticmethod
+    def _relevance_threshold(top_score: float) -> float:
+        """Compute the minimum relevance score to include a file.
+
+        Files below this threshold are considered noise.
+
+        Args:
+            top_score: The highest file relevance score.
+
+        Returns:
+            Threshold value (at least 1.0).
+        """
+        return max(top_score * 0.10, 1.0)
+
+    @staticmethod
+    def _extract_signatures(file_path: str, builder: IndexBuilder, index: CodeIndex) -> str:
+        """Extract function/class signatures for a file as a compact summary.
+
+        Args:
+            file_path: Relative file path.
+            builder: IndexBuilder instance.
+            index: Pre-loaded code index.
+
+        Returns:
+            Formatted string of signatures, or empty string if none found.
+        """
+        symbols = builder.get_file_symbols(file_path, index)
+        if not symbols:
+            return ""
+
+        parts: list[str] = []
+        for sym in symbols:
+            if sym.kind == "import":
+                continue
+            parts.append(sym.signature)
+            if sym.docstring:
+                parts.append(f"    {sym.docstring}")
+        return "\n".join(parts)

nex/exceptions.py

@@ -0,0 +1,39 @@
+"""Nex AI exception hierarchy.
+
+All exceptions inherit from NexError so callers can catch the base
+class when they want to handle any Nex-specific failure uniformly.
+"""
+
+from __future__ import annotations
+
+
+class NexError(Exception):
+    """Base exception for all Nex errors."""
+
+
+class ConfigError(NexError):
+    """Configuration-related errors (missing API key, invalid config, etc.)."""
+
+
+class APIError(NexError):
+    """Errors communicating with the Anthropic API."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class ToolError(NexError):
+    """Errors during tool execution (file ops, shell commands, etc.)."""
+
+
+class SafetyError(NexError):
+    """Safety layer violations (destructive commands, path traversal, etc.)."""
+
+
+class IndexerError(NexError):
+    """Errors during codebase indexing or AST parsing."""
+
+
+class NexMemoryError(NexError):
+    """Errors in the memory system (project memory, error DB, decision log)."""

nex/indexer/__init__.py

@@ -0,0 +1,16 @@
+"""Codebase indexer — file discovery, AST parsing, and index building."""
+
+from __future__ import annotations
+
+from nex.indexer.index import CodeIndex, IndexBuilder
+from nex.indexer.parser import ASTParser, Symbol
+from nex.indexer.scanner import FileInfo, FileScanner
+
+__all__ = [
+    "ASTParser",
+    "CodeIndex",
+    "FileInfo",
+    "FileScanner",
+    "IndexBuilder",
+    "Symbol",
+]