nexcoder 0.1.3__tar.gz → 0.1.5__tar.gz

{nexcoder-0.1.3 → nexcoder-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexcoder
-Version: 0.1.3
+Version: 0.1.5
 Summary: The coding agent that remembers — AI coding assistant with persistent memory and error learning.
 Project-URL: Homepage, https://github.com/nex-ai/nex-ai
 Project-URL: Repository, https://github.com/nex-ai/nex-ai

{nexcoder-0.1.3 → nexcoder-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nexcoder"
-version = "0.1.3"
+version = "0.1.5"
 description = "The coding agent that remembers — AI coding assistant with persistent memory and error learning."
 readme = {file = "README.md", content-type = "text/markdown"}
 license = "MIT"

{nexcoder-0.1.3 → nexcoder-0.1.5}/src/nex/__init__.py

@@ -2,5 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+from importlib.metadata import version
+
+__version__ = version("nexcoder")
 __app_name__ = "nex"

{nexcoder-0.1.3 → nexcoder-0.1.5}/src/nex/agent.py

@@ -438,9 +438,10 @@ class Agent:
             haiku_model = self._nex_config.haiku_model
 
         planner = Planner(self._client, haiku_model=haiku_model)
+        rate_limiter = RateLimiter(tokens_per_minute=token_rate_limit)
 
         console.print("\n[bold]Decomposing task into subtasks...[/bold]")
-        subtasks = await planner.plan(self._config.task, project_memory)
+        subtasks = await planner.plan(self._config.task, project_memory, rate_limiter)
 
         console.print(f"\n[bold]Running task:[/bold] {self._config.task}")
         rate_info = f"Rate limit: {token_rate_limit} tokens/min | " if token_rate_limit else ""
@@ -449,8 +450,6 @@ class Agent:
             f"{rate_info}"
             f"Max iterations: {self._config.max_iterations}[/dim]\n"
         )
-
-        rate_limiter = RateLimiter(tokens_per_minute=token_rate_limit)
         budget = 20_000
         if self._nex_config:
             budget = self._nex_config.subtask_token_budget

{nexcoder-0.1.3 → nexcoder-0.1.5}/src/nex/api_client.py

@@ -122,6 +122,30 @@ class RateLimiter:
                 return
 
 
+def _extract_retry_after(exc: Exception, default: float = 60.0) -> float:
+    """Extract retry-after seconds from an Anthropic API error.
+
+    Inspects the exception's response headers for a ``retry-after`` value.
+    Falls back to *default* if the header is missing or unparseable.
+
+    Args:
+        exc: The exception raised by the Anthropic SDK.
+        default: Fallback wait time in seconds.
+
+    Returns:
+        Number of seconds to wait before retrying.
+    """
+    resp = getattr(exc, "response", None)
+    if resp is not None:
+        header = getattr(resp, "headers", {}).get("retry-after")
+        if header:
+            try:
+                return max(float(header), 1.0)
+            except (ValueError, TypeError):
+                pass
+    return default
+
+
 class AnthropicClient:
     """Async wrapper around the Anthropic API.
 
@@ -140,7 +164,7 @@ class AnthropicClient:
         self,
         api_key: str,
         default_model: str = "claude-sonnet-4-20250514",
-        max_retries: int = 3,
+        max_retries: int = 5,
     ) -> None:
         """Initialize the Anthropic client.
 
@@ -196,7 +220,9 @@ class AnthropicClient:
             kwargs["tools"] = tools
 
         last_error: Exception | None = None
-        for attempt in range(self._max_retries + 1):
+        # 429 rate limits need more retries with longer waits than server errors
+        max_attempts = self._max_retries + 1
+        for attempt in range(max_attempts):
             try:
                 response = await self._client.messages.create(**kwargs)
 
@@ -230,16 +256,21 @@ class AnthropicClient:
             except Exception as exc:
                 last_error = exc
                 status_code = getattr(exc, "status_code", None)
+                is_rate_limit = status_code == 429
+                is_retryable = status_code in (500, 502, 503, 529)
+
+                if (is_rate_limit or is_retryable) and attempt < max_attempts - 1:
+                    if is_rate_limit:
+                        # Rate limits: extract retry-after from response headers,
+                        # or default to 60s (the full rate-limit window).
+                        wait = _extract_retry_after(exc, default=60.0)
+                    else:
+                        # Server errors: short exponential backoff
+                        wait = float(2**attempt)
 
-                # Retry on rate limit or server errors
-                if status_code in (429, 500, 502, 503, 529) and attempt < self._max_retries:
-                    wait = 2**attempt
-                    retry_after = getattr(exc, "retry_after", None)
-                    if retry_after:
-                        wait = max(wait, float(retry_after))
                     console.print(
-                        f"[yellow]API error {status_code}, retrying in {wait}s "
-                        f"(attempt {attempt + 1}/{self._max_retries})...[/yellow]"
+                        f"[yellow]API error {status_code}, retrying in {wait:.0f}s "
+                        f"(attempt {attempt + 1}/{max_attempts - 1})...[/yellow]"
                     )
                     await asyncio.sleep(wait)
                     continue
@@ -250,7 +281,7 @@ class AnthropicClient:
                 ) from exc
 
         raise APIError(
-            f"Failed after {self._max_retries} retries: {last_error}",
+            f"Failed after {max_attempts - 1} retries: {last_error}",
         )
 
     async def close(self) -> None:

{nexcoder-0.1.3 → nexcoder-0.1.5}/src/nex/cli.py

@@ -59,7 +59,7 @@ _CONFIG_TEMPLATE = """\
 # model = "claude-sonnet-4-20250514"
 # max_iterations = 25
 # dry_run = false
-token_rate_limit = 25000
+token_rate_limit = 20000
 """
 
 

{nexcoder-0.1.3 → nexcoder-0.1.5}/src/nex/config.py

@@ -52,7 +52,7 @@ class NexConfig:
     nex_dir: Path = field(default_factory=lambda: Path(".nex"))
     test_command: str = ""
     test_timeout: int = 120
-    token_rate_limit: int = 25_000
+    token_rate_limit: int = 20_000
     subtask_token_budget: int = 20_000
 
 

{nexcoder-0.1.3 → nexcoder-0.1.5}/src/nex/planner.py

@@ -8,7 +8,7 @@ from typing import Any
 
 from rich.console import Console
 
-from nex.api_client import AnthropicClient
+from nex.api_client import AnthropicClient, RateLimiter
 
 console = Console(stderr=True)
 
@@ -60,25 +60,36 @@ class Planner:
         self._client = api_client
         self._model = haiku_model
 
-    async def plan(self, task: str, project_context: str) -> list[Subtask]:
+    async def plan(
+        self,
+        task: str,
+        project_context: str,
+        rate_limiter: RateLimiter | None = None,
+    ) -> list[Subtask]:
         """Decompose a task into subtasks.
 
         Args:
             task: The user's task description.
             project_context: Project memory and relevant context.
+            rate_limiter: Optional rate limiter to pace the API call.
 
         Returns:
             List of Subtask instances sorted by priority.
         """
+        user_content = f"Project context:\n{project_context}\n\nTask: {task}"
         messages: list[dict[str, Any]] = [
             {
                 "role": "user",
-                "content": f"Project context:\n{project_context}\n\nTask: {task}",
+                "content": user_content,
             }
         ]
 
         console.print("[dim]Planning task decomposition...[/dim]")
 
+        if rate_limiter is not None:
+            estimated = len(user_content) // 4
+            await rate_limiter.wait_if_needed(estimated)
+
         response = await self._client.send_message(
             messages=messages,
             system=_PLANNER_SYSTEM_PROMPT,
@@ -86,6 +97,9 @@ class Planner:
             max_tokens=2048,
         )
 
+        if rate_limiter is not None:
+            rate_limiter.record(response.input_tokens)
+
         # Extract text response
         text = ""
         for block in response.content: