anycode-py 0.1.0__py3-none-any.whl

anycode/helpers/concurrency_gate.py

@@ -0,0 +1,45 @@
+"""Bounded concurrency gate for parallel task limiting."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+class Semaphore:
+    """Async semaphore with active/pending tracking."""
+
+    def __init__(self, max_concurrency: int) -> None:
+        if max_concurrency < 1:
+            raise ValueError(f"Concurrency limit must be >= 1, received {max_concurrency}")
+        self._semaphore = asyncio.Semaphore(max_concurrency)
+        self._active = 0
+        self._pending = 0
+
+    async def acquire(self) -> None:
+        self._pending += 1
+        await self._semaphore.acquire()
+        self._pending -= 1
+        self._active += 1
+
+    def release(self) -> None:
+        self._active -= 1
+        self._semaphore.release()
+
+    async def run(self, fn: Callable[[], Awaitable[T]]) -> T:
+        await self.acquire()
+        try:
+            return await fn()
+        finally:
+            self.release()
+
+    @property
+    def active(self) -> int:
+        return self._active
+
+    @property
+    def pending(self) -> int:
+        return self._pending

anycode/helpers/usage_tracker.py

@@ -0,0 +1,14 @@
+"""Shared token-usage helpers."""
+
+from __future__ import annotations
+
+from anycode.types import TokenUsage
+
+EMPTY_USAGE = TokenUsage(input_tokens=0, output_tokens=0)
+
+
+def merge_usage(a: TokenUsage, b: TokenUsage) -> TokenUsage:
+    return TokenUsage(
+        input_tokens=a.input_tokens + b.input_tokens,
+        output_tokens=a.output_tokens + b.output_tokens,
+    )

anycode/providers/__init__.py

@@ -0,0 +1,3 @@
+from anycode.providers.adapter import create_adapter
+
+__all__ = ["create_adapter"]

anycode/providers/adapter.py

@@ -0,0 +1,22 @@
+"""Provider factory — resolves the appropriate LLM backend on demand."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from anycode.types import LLMAdapter
+
+SupportedProvider = str  # "anthropic" | "openai"
+
+
+async def create_adapter(provider: str, api_key: str | None = None) -> LLMAdapter:
+    """Lazy-load the provider SDK and return an adapter instance."""
+    if provider == "anthropic":
+        from anycode.providers.anthropic import AnthropicAdapter
+        return AnthropicAdapter(api_key=api_key)
+    elif provider == "openai":
+        from anycode.providers.openai import OpenAIAdapter
+        return OpenAIAdapter(api_key=api_key)
+    else:
+        raise ValueError(f"Unknown provider requested: {provider}")

anycode/providers/anthropic.py

@@ -0,0 +1,149 @@
+"""Anthropic SDK adapter."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import AsyncIterator
+from typing import Any
+
+import anthropic
+
+from anycode.types import (
+    ContentBlock,
+    LLMChatOptions,
+    LLMMessage,
+    LLMResponse,
+    LLMStreamOptions,
+    LLMToolDef,
+    StreamEvent,
+    TextBlock,
+    TokenUsage,
+    ToolUseBlock,
+)
+
+
+def _map_content_block(block: ContentBlock) -> dict[str, Any]:
+    if block.type == "text":
+        return {"type": "text", "text": block.text}
+    elif block.type == "tool_use":
+        return {"type": "tool_use", "id": block.id, "name": block.name, "input": block.input}
+    elif block.type == "tool_result":
+        result: dict[str, Any] = {"type": "tool_result", "tool_use_id": block.tool_use_id, "content": block.content}
+        if block.is_error is not None:
+            result["is_error"] = block.is_error
+        return result
+    elif block.type == "image":
+        return {"type": "image", "source": {"type": "base64", "media_type": block.source.media_type, "data": block.source.data}}
+    raise ValueError(f"Unexpected block type: {block.type}")
+
+
+def _map_messages(messages: list[LLMMessage]) -> list[dict[str, Any]]:
+    return [{"role": msg.role, "content": [_map_content_block(b) for b in msg.content]} for msg in messages]
+
+
+def _map_tool_defs(tools: list[LLMToolDef]) -> list[dict[str, Any]]:
+    return [{"name": t.name, "description": t.description, "input_schema": {"type": "object", **t.input_schema}} for t in tools]
+
+
+def _parse_block(block: Any) -> ContentBlock:
+    if block.type == "text":
+        return TextBlock(text=block.text)
+    elif block.type == "tool_use":
+        return ToolUseBlock(id=block.id, name=block.name, input=block.input if isinstance(block.input, dict) else {})
+    return TextBlock(text=f"[unrecognized block: {block.type}]")
+
+
+class AnthropicAdapter:
+    """Wraps the Anthropic Python SDK."""
+
+    def __init__(self, api_key: str | None = None) -> None:
+        self._client = anthropic.AsyncAnthropic(api_key=api_key or os.environ.get("ANTHROPIC_API_KEY"))
+
+    @property
+    def name(self) -> str:
+        return "anthropic"
+
+    async def chat(self, messages: list[LLMMessage], options: LLMChatOptions) -> LLMResponse:
+        mapped = _map_messages(messages)
+        kwargs: dict[str, Any] = {
+            "model": options.model,
+            "max_tokens": options.max_tokens or 4096,
+            "messages": mapped,
+        }
+        if options.system_prompt:
+            kwargs["system"] = options.system_prompt
+        if options.tools:
+            kwargs["tools"] = _map_tool_defs(options.tools)
+        if options.temperature is not None:
+            kwargs["temperature"] = options.temperature
+
+        response = await self._client.messages.create(**kwargs)
+
+        return LLMResponse(
+            id=response.id,
+            content=[_parse_block(b) for b in response.content],
+            model=response.model,
+            stop_reason=response.stop_reason or "end_turn",
+            usage=TokenUsage(input_tokens=response.usage.input_tokens, output_tokens=response.usage.output_tokens),
+        )
+
+    async def stream(self, messages: list[LLMMessage], options: LLMStreamOptions) -> AsyncIterator[StreamEvent]:
+        mapped = _map_messages(messages)
+        kwargs: dict[str, Any] = {
+            "model": options.model,
+            "max_tokens": options.max_tokens or 4096,
+            "messages": mapped,
+        }
+        if options.system_prompt:
+            kwargs["system"] = options.system_prompt
+        if options.tools:
+            kwargs["tools"] = _map_tool_defs(options.tools)
+        if options.temperature is not None:
+            kwargs["temperature"] = options.temperature
+
+        json_buffers: dict[int, dict[str, str]] = {}
+
+        try:
+            async with self._client.messages.stream(**kwargs) as stream:
+                async for event in stream:
+                    if event.type == "content_block_start":
+                        block = event.content_block
+                        if block.type == "tool_use":
+                            json_buffers[event.index] = {"id": block.id, "name": block.name, "json": ""}
+                    elif event.type == "content_block_delta":
+                        delta = event.delta
+                        if delta.type == "text_delta":
+                            yield StreamEvent(type="text", data=delta.text)
+                        elif delta.type == "input_json_delta":
+                            buf = json_buffers.get(event.index)
+                            if buf is not None:
+                                buf["json"] += delta.partial_json
+                    elif event.type == "content_block_stop":
+                        buf = json_buffers.pop(event.index, None)
+                        if buf is not None:
+                            parsed_input: dict[str, Any] = {}
+                            try:
+                                parsed = json.loads(buf["json"])
+                                if isinstance(parsed, dict):
+                                    parsed_input = parsed
+                            except (json.JSONDecodeError, TypeError):
+                                pass
+                            yield StreamEvent(
+                                type="tool_use",
+                                data=ToolUseBlock(id=buf["id"], name=buf["name"], input=parsed_input),
+                            )
+
+                final = await stream.get_final_message()
+                yield StreamEvent(
+                    type="done",
+                    data=LLMResponse(
+                        id=final.id,
+                        content=[_parse_block(b) for b in final.content],
+                        model=final.model,
+                        stop_reason=final.stop_reason or "end_turn",
+                        usage=TokenUsage(input_tokens=final.usage.input_tokens, output_tokens=final.usage.output_tokens),
+                    ),
+                )
+        except Exception as e:
+            yield StreamEvent(type="error", data=str(e))

anycode/providers/openai.py

@@ -0,0 +1,208 @@
+"""OpenAI SDK adapter."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import AsyncIterator
+from typing import Any
+
+import openai
+
+from anycode.types import (
+    ContentBlock,
+    LLMChatOptions,
+    LLMMessage,
+    LLMResponse,
+    LLMStreamOptions,
+    LLMToolDef,
+    StreamEvent,
+    TextBlock,
+    TokenUsage,
+    ToolUseBlock,
+)
+
+
+def _map_tool_def(tool: LLMToolDef) -> dict[str, Any]:
+    return {"type": "function", "function": {"name": tool.name, "description": tool.description, "parameters": tool.input_schema}}
+
+
+def _map_messages(messages: list[LLMMessage], system_prompt: str | None) -> list[dict[str, Any]]:
+    result: list[dict[str, Any]] = []
+    if system_prompt:
+        result.append({"role": "system", "content": system_prompt})
+
+    for msg in messages:
+        if msg.role == "assistant":
+            result.append(_map_assistant(msg))
+        else:
+            has_tool_results = any(b.type == "tool_result" for b in msg.content)
+            if not has_tool_results:
+                result.append(_map_user(msg))
+            else:
+                non_tool = [b for b in msg.content if b.type != "tool_result"]
+                if non_tool:
+                    result.append(_map_user(LLMMessage(role="user", content=non_tool)))
+                for b in msg.content:
+                    if b.type == "tool_result":
+                        result.append({"role": "tool", "tool_call_id": b.tool_use_id, "content": b.content})
+    return result
+
+
+def _map_user(msg: LLMMessage) -> dict[str, Any]:
+    if len(msg.content) == 1 and msg.content[0].type == "text":
+        return {"role": "user", "content": msg.content[0].text}
+    parts: list[dict[str, Any]] = []
+    for b in msg.content:
+        if b.type == "text":
+            parts.append({"type": "text", "text": b.text})
+        elif b.type == "image":
+            parts.append({"type": "image_url", "image_url": {"url": f"data:{b.source.media_type};base64,{b.source.data}"}})
+    return {"role": "user", "content": parts}
+
+
+def _map_assistant(msg: LLMMessage) -> dict[str, Any]:
+    tool_calls = []
+    text_parts: list[str] = []
+    for b in msg.content:
+        if b.type == "tool_use":
+            tool_calls.append({"id": b.id, "type": "function", "function": {"name": b.name, "arguments": json.dumps(b.input)}})
+        elif b.type == "text":
+            text_parts.append(b.text)
+    result: dict[str, Any] = {"role": "assistant", "content": "".join(text_parts) if text_parts else None}
+    if tool_calls:
+        result["tool_calls"] = tool_calls
+    return result
+
+
+def _map_stop_reason(reason: str | None) -> str:
+    mapping = {"stop": "end_turn", "tool_calls": "tool_use", "length": "max_tokens", "content_filter": "content_filter"}
+    return mapping.get(reason or "stop", reason or "end_turn")
+
+
+def _parse_json_safe(s: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(s)
+        if isinstance(parsed, dict):
+            return parsed
+    except (json.JSONDecodeError, TypeError):
+        pass
+    return {}
+
+
+class OpenAIAdapter:
+    """Wraps the OpenAI Python SDK."""
+
+    def __init__(self, api_key: str | None = None) -> None:
+        self._client = openai.AsyncOpenAI(api_key=api_key or os.environ.get("OPENAI_API_KEY"))
+
+    @property
+    def name(self) -> str:
+        return "openai"
+
+    async def chat(self, messages: list[LLMMessage], options: LLMChatOptions) -> LLMResponse:
+        oai_msgs = _map_messages(messages, options.system_prompt)
+        kwargs: dict[str, Any] = {"model": options.model, "messages": oai_msgs}
+        if options.max_tokens:
+            kwargs["max_tokens"] = options.max_tokens
+        if options.temperature is not None:
+            kwargs["temperature"] = options.temperature
+        if options.tools:
+            kwargs["tools"] = [_map_tool_def(t) for t in options.tools]
+
+        completion = await self._client.chat.completions.create(**kwargs)
+        choice = completion.choices[0]
+        content: list[ContentBlock] = []
+
+        if choice.message.content:
+            content.append(TextBlock(text=choice.message.content))
+        for tc in choice.message.tool_calls or []:
+            content.append(ToolUseBlock(id=tc.id, name=tc.function.name, input=_parse_json_safe(tc.function.arguments)))
+
+        return LLMResponse(
+            id=completion.id,
+            content=content,
+            model=completion.model,
+            stop_reason=_map_stop_reason(choice.finish_reason),
+            usage=TokenUsage(
+                input_tokens=completion.usage.prompt_tokens if completion.usage else 0,
+                output_tokens=completion.usage.completion_tokens if completion.usage else 0,
+            ),
+        )
+
+    async def stream(self, messages: list[LLMMessage], options: LLMStreamOptions) -> AsyncIterator[StreamEvent]:
+        oai_msgs = _map_messages(messages, options.system_prompt)
+        kwargs: dict[str, Any] = {"model": options.model, "messages": oai_msgs, "stream": True, "stream_options": {"include_usage": True}}
+        if options.max_tokens:
+            kwargs["max_tokens"] = options.max_tokens
+        if options.temperature is not None:
+            kwargs["temperature"] = options.temperature
+        if options.tools:
+            kwargs["tools"] = [_map_tool_def(t) for t in options.tools]
+
+        completion_id = ""
+        completion_model = ""
+        last_stop = "stop"
+        prompt_tokens = 0
+        gen_tokens = 0
+        json_buffers: dict[int, dict[str, str]] = {}
+        full_text = ""
+
+        try:
+            stream_resp = await self._client.chat.completions.create(**kwargs)
+            async for chunk in stream_resp:
+                completion_id = chunk.id
+                completion_model = chunk.model
+
+                if chunk.usage:
+                    prompt_tokens = chunk.usage.prompt_tokens
+                    gen_tokens = chunk.usage.completion_tokens
+
+                if not chunk.choices:
+                    continue
+                choice = chunk.choices[0]
+                delta = choice.delta
+
+                if delta.content:
+                    full_text += delta.content
+                    yield StreamEvent(type="text", data=delta.content)
+
+                for tc_delta in delta.tool_calls or []:
+                    idx = tc_delta.index
+                    if idx not in json_buffers:
+                        json_buffers[idx] = {"id": tc_delta.id or "", "name": (tc_delta.function and tc_delta.function.name) or "", "args": ""}
+                    buf = json_buffers[idx]
+                    if tc_delta.id:
+                        buf["id"] = tc_delta.id
+                    if tc_delta.function and tc_delta.function.name:
+                        buf["name"] = tc_delta.function.name
+                    if tc_delta.function and tc_delta.function.arguments:
+                        buf["args"] += tc_delta.function.arguments
+
+                if choice.finish_reason:
+                    last_stop = choice.finish_reason
+
+            # Flush tool call buffers
+            tool_blocks: list[ToolUseBlock] = []
+            for buf in json_buffers.values():
+                block = ToolUseBlock(id=buf["id"], name=buf["name"], input=_parse_json_safe(buf["args"]))
+                tool_blocks.append(block)
+                yield StreamEvent(type="tool_use", data=block)
+
+            done_content: list[ContentBlock] = []
+            if full_text:
+                done_content.append(TextBlock(text=full_text))
+            done_content.extend(tool_blocks)
+
+            yield StreamEvent(
+                type="done",
+                data=LLMResponse(
+                    id=completion_id,
+                    content=done_content,
+                    model=completion_model,
+                    stop_reason=_map_stop_reason(last_stop),
+                    usage=TokenUsage(input_tokens=prompt_tokens, output_tokens=gen_tokens),
+                ),
+            )
+        except Exception as e:
+            yield StreamEvent(type="error", data=str(e))

anycode/tasks/__init__.py

@@ -0,0 +1,4 @@
+from anycode.tasks.queue import TaskQueue
+from anycode.tasks.task import create_task, get_task_dependency_order, is_task_ready, validate_task_dependencies
+
+__all__ = ["TaskQueue", "create_task", "is_task_ready", "get_task_dependency_order", "validate_task_dependencies"]

anycode/tasks/queue.py

@@ -0,0 +1,139 @@
+"""Event-driven task queue with dependency resolution and cascading failure."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import UTC, datetime
+
+from anycode.tasks.task import is_task_ready
+from anycode.types import Task, TaskStatus
+
+
+class TaskQueue:
+    """Manages tasks with dependency blocking, cascading failure, and event notifications."""
+
+    def __init__(self) -> None:
+        self._tasks: dict[str, Task] = {}
+        self._listeners: dict[str, dict[int, Callable[..., None]]] = {}
+        self._next_id = 0
+
+    def add(self, task: Task) -> None:
+        resolved = self._determine_initial_status(task)
+        self._tasks[resolved.id] = resolved
+        if resolved.status == "pending":
+            self._emit("task:ready", resolved)
+
+    def add_batch(self, tasks: list[Task]) -> None:
+        for task in tasks:
+            self.add(task)
+
+    def update(self, task_id: str, **kwargs: str | TaskStatus | None) -> Task:
+        task = self._lookup(task_id)
+        updated = task.model_copy(update={**kwargs, "updated_at": datetime.now(UTC)})
+        self._tasks[task_id] = updated
+        return updated
+
+    def complete(self, task_id: str, result: str | None = None) -> Task:
+        completed = self.update(task_id, status="completed", result=result)
+        self._emit("task:complete", completed)
+        self._promote_blocked(task_id)
+        if self.is_done():
+            self._emit_all_complete()
+        return completed
+
+    def fail(self, task_id: str, error: str) -> Task:
+        failed = self.update(task_id, status="failed", result=error)
+        self._emit("task:failed", failed)
+        self._propagate_failure(task_id)
+        if self.is_done():
+            self._emit_all_complete()
+        return failed
+
+    def next(self, assignee: str | None = None) -> Task | None:
+        if assignee is None:
+            return self.next_available()
+        for task in self._tasks.values():
+            if task.status == "pending" and task.assignee == assignee:
+                return task
+        return None
+
+    def next_available(self) -> Task | None:
+        fallback: Task | None = None
+        for task in self._tasks.values():
+            if task.status != "pending":
+                continue
+            if not task.assignee:
+                return task
+            if fallback is None:
+                fallback = task
+        return fallback
+
+    def list(self) -> list[Task]:
+        return list(self._tasks.values())
+
+    def get_by_status(self, status: TaskStatus) -> list[Task]:
+        return [t for t in self._tasks.values() if t.status == status]
+
+    def is_done(self) -> bool:
+        return all(t.status in ("completed", "failed") for t in self._tasks.values())
+
+    def get_progress(self) -> dict[str, int]:
+        counts = {"total": len(self._tasks), "completed": 0, "failed": 0, "in_progress": 0, "pending": 0, "blocked": 0}
+        for t in self._tasks.values():
+            key = t.status if t.status != "in_progress" else "in_progress"
+            counts[key] = counts.get(key, 0) + 1
+        return counts
+
+    def on(self, event: str, handler: Callable[..., None]) -> Callable[[], None]:
+        subs = self._listeners.setdefault(event, {})
+        sub_id = self._next_id
+        self._next_id += 1
+        subs[sub_id] = handler
+        return lambda: subs.pop(sub_id, None)
+
+    def _determine_initial_status(self, task: Task) -> Task:
+        if not task.depends_on:
+            return task
+        all_current = list(self._tasks.values())
+        if is_task_ready(task, all_current):
+            return task
+        return task.model_copy(update={"status": "blocked", "updated_at": datetime.now(UTC)})
+
+    def _promote_blocked(self, completed_id: str) -> None:
+        all_tasks = list(self._tasks.values())
+        task_by_id = {t.id: t for t in all_tasks}
+        for task in all_tasks:
+            if task.status != "blocked":
+                continue
+            if not task.depends_on or completed_id not in task.depends_on:
+                continue
+            as_pending = task.model_copy(update={"status": "pending"})
+            if is_task_ready(as_pending, all_tasks, task_by_id):
+                unblocked = task.model_copy(update={"status": "pending", "updated_at": datetime.now(UTC)})
+                self._tasks[task.id] = unblocked
+                task_by_id[task.id] = unblocked
+                self._emit("task:ready", unblocked)
+
+    def _propagate_failure(self, failed_id: str) -> None:
+        for task in list(self._tasks.values()):
+            if task.status not in ("blocked", "pending"):
+                continue
+            if not task.depends_on or failed_id not in task.depends_on:
+                continue
+            cascaded = self.update(task.id, status="failed", result=f'Cancelled: prerequisite "{failed_id}" failed.')
+            self._emit("task:failed", cascaded)
+            self._propagate_failure(task.id)
+
+    def _emit(self, event: str, task: Task) -> None:
+        for handler in self._listeners.get(event, {}).values():
+            handler(task)
+
+    def _emit_all_complete(self) -> None:
+        for handler in self._listeners.get("all:complete", {}).values():
+            handler()
+
+    def _lookup(self, task_id: str) -> Task:
+        task = self._tasks.get(task_id)
+        if not task:
+            raise ValueError(f'TaskQueue: no task with id "{task_id}".')
+        return task