anycode-py 0.1.0__py3-none-any.whl

anycode/tasks/task.py

@@ -0,0 +1,104 @@
+"""Task utilities — creation, readiness checks, topological sort, and cycle detection."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from uuid import uuid4
+
+from anycode.types import Task
+
+
+def create_task(
+    *, title: str, description: str, assignee: str | None = None, depends_on: list[str] | None = None
+) -> Task:
+    now = datetime.now(UTC)
+    return Task(
+        id=str(uuid4()),
+        title=title,
+        description=description,
+        status="pending",
+        assignee=assignee,
+        depends_on=list(depends_on) if depends_on else None,
+        created_at=now,
+        updated_at=now,
+    )
+
+
+def is_task_ready(task: Task, all_tasks: list[Task], task_by_id: dict[str, Task] | None = None) -> bool:
+    """True when task is pending and every dependency has completed."""
+    if task.status != "pending":
+        return False
+    if not task.depends_on:
+        return True
+    lookup = task_by_id or {t.id: t for t in all_tasks}
+    stub = Task(id="", title="", description="", created_at=datetime.min, updated_at=datetime.min)
+    return all(lookup.get(dep_id, stub).status == "completed" for dep_id in task.depends_on)
+
+
+def get_task_dependency_order(tasks: list[Task]) -> list[Task]:
+    """Topological ordering via Kahn's algorithm."""
+    if not tasks:
+        return []
+
+    task_by_id = {t.id: t for t in tasks}
+    in_degree: dict[str, int] = {t.id: 0 for t in tasks}
+    successors: dict[str, list[str]] = {t.id: [] for t in tasks}
+
+    for task in tasks:
+        for dep_id in task.depends_on or []:
+            if dep_id in task_by_id:
+                in_degree[task.id] = in_degree.get(task.id, 0) + 1
+                successors.setdefault(dep_id, []).append(task.id)
+
+    frontier = [tid for tid, deg in in_degree.items() if deg == 0]
+    ordered: list[Task] = []
+
+    while frontier:
+        tid = frontier.pop(0)
+        task = task_by_id.get(tid)
+        if task:
+            ordered.append(task)
+        for succ in successors.get(tid, []):
+            in_degree[succ] -= 1
+            if in_degree[succ] == 0:
+                frontier.append(succ)
+
+    return ordered
+
+
+def validate_task_dependencies(tasks: list[Task]) -> tuple[bool, list[str]]:
+    """Check dependency graph for missing refs, self-references, and cycles."""
+    errors: list[str] = []
+    task_by_id = {t.id: t for t in tasks}
+
+    for task in tasks:
+        for dep_id in task.depends_on or []:
+            if dep_id == task.id:
+                errors.append(f'Task "{task.title}" ({task.id}) has a self-dependency.')
+                continue
+            if dep_id not in task_by_id:
+                errors.append(f'Task "{task.title}" ({task.id}) references missing dependency "{dep_id}".')
+
+    # Cycle detection via DFS colouring
+    color: dict[str, int] = {t.id: 0 for t in tasks}  # 0=white, 1=gray, 2=black
+
+    def visit(tid: str, path: list[str]) -> None:
+        if color.get(tid) == 2:
+            return
+        if color.get(tid) == 1:
+            cycle_start = path.index(tid)
+            cycle = path[cycle_start:] + [tid]
+            errors.append(f"Dependency cycle found: {' -> '.join(cycle)}")
+            return
+        color[tid] = 1
+        task = task_by_id.get(tid)
+        for dep_id in (task.depends_on or []) if task else []:
+            if dep_id in task_by_id:
+                visit(dep_id, [*path, tid])
+        color[tid] = 2
+
+    for task in tasks:
+        if color.get(task.id) == 0:
+            visit(task.id, [])
+
+    return (len(errors) == 0, errors)

anycode/tools/__init__.py

@@ -0,0 +1,21 @@
+from anycode.tools.bash import bash_tool
+from anycode.tools.built_in import BUILT_IN_TOOLS, register_built_in_tools
+from anycode.tools.executor import ToolExecutor
+from anycode.tools.file_edit import file_edit_tool
+from anycode.tools.file_read import file_read_tool
+from anycode.tools.file_write import file_write_tool
+from anycode.tools.grep import grep_tool
+from anycode.tools.registry import ToolRegistry, define_tool
+
+__all__ = [
+    "ToolRegistry",
+    "ToolExecutor",
+    "define_tool",
+    "register_built_in_tools",
+    "BUILT_IN_TOOLS",
+    "bash_tool",
+    "file_read_tool",
+    "file_write_tool",
+    "file_edit_tool",
+    "grep_tool",
+]

anycode/tools/bash.py

@@ -0,0 +1,67 @@
+"""Shell execution tool — runs commands with configurable timeout."""
+
+from __future__ import annotations
+
+import asyncio
+
+from pydantic import BaseModel, Field
+
+from anycode.tools.registry import define_tool
+from anycode.types import ToolResult, ToolUseContext
+
+TIMEOUT_LIMIT_S = 30
+
+
+class BashInput(BaseModel):
+    command: str = Field(description="The shell command to run.")
+    timeout: float | None = Field(default=None, description=f"Time limit in seconds. Defaults to {TIMEOUT_LIMIT_S}s.")
+    cwd: str | None = Field(default=None, description="Directory to execute the command in.")
+
+
+async def _execute(input: BashInput, context: ToolUseContext) -> ToolResult:
+    limit = input.timeout or TIMEOUT_LIMIT_S
+    stdout, stderr, exit_code = await _exec_command(input.command, cwd=input.cwd, timeout=limit)
+    return ToolResult(data=_compose_result(stdout, stderr, exit_code), is_error=exit_code != 0)
+
+
+async def _exec_command(command: str, cwd: str | None, timeout: float) -> tuple[str, str, int]:
+    try:
+        proc = await asyncio.create_subprocess_shell(
+            command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd,
+        )
+        try:
+            stdout_bytes, stderr_bytes = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        except TimeoutError:
+            proc.kill()
+            await proc.wait()
+            return "", "Process timed out", 124
+        return (
+            stdout_bytes.decode("utf-8", errors="replace"),
+            stderr_bytes.decode("utf-8", errors="replace"),
+            proc.returncode or 0,
+        )
+    except Exception as e:
+        return "", str(e), 127
+
+
+def _compose_result(stdout: str, stderr: str, exit_code: int) -> str:
+    parts: list[str] = []
+    if stdout:
+        parts.append(stdout)
+    if stderr:
+        parts.append(f"-- stderr --\n{stderr}" if stdout else stderr)
+    if not parts:
+        return "(completed silently — no output)" if exit_code == 0 else f"(exited with code {exit_code} — no output produced)"
+    if exit_code != 0:
+        parts.append(f"\n(exit code {exit_code})")
+    return "\n".join(parts)
+
+
+bash_tool = define_tool(name="bash", description=(
+    "Run a shell command and capture its stdout and stderr. "
+    "Useful for file-system tasks, script execution, package management, "
+    "or anything requiring a shell session."
+), input_model=BashInput, execute=_execute)

anycode/tools/built_in.py

@@ -0,0 +1,18 @@
+"""Default tool set — bulk-register every bundled tool."""
+
+from __future__ import annotations
+
+from anycode.tools.bash import bash_tool
+from anycode.tools.file_edit import file_edit_tool
+from anycode.tools.file_read import file_read_tool
+from anycode.tools.file_write import file_write_tool
+from anycode.tools.grep import grep_tool
+from anycode.tools.registry import ToolRegistry
+from anycode.types import ToolDefinition
+
+BUILT_IN_TOOLS: list[ToolDefinition] = [bash_tool, file_read_tool, file_write_tool, file_edit_tool, grep_tool]
+
+
+def register_built_in_tools(registry: ToolRegistry) -> None:
+    for tool in BUILT_IN_TOOLS:
+        registry.register(tool)

anycode/tools/executor.py

@@ -0,0 +1,51 @@
+"""Concurrent tool dispatcher with Pydantic validation."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from anycode.helpers.concurrency_gate import Semaphore
+from anycode.tools.registry import ToolRegistry
+from anycode.types import BatchToolCall, ToolDefinition, ToolResult, ToolUseContext
+
+
+class ToolExecutor:
+    """Validates inputs via Pydantic then invokes tools, with semaphore-bounded batch execution."""
+
+    def __init__(self, registry: ToolRegistry, max_concurrency: int = 4) -> None:
+        self._registry = registry
+        self._semaphore = Semaphore(max_concurrency)
+
+    async def execute(self, tool_name: str, raw_input: dict[str, Any], context: ToolUseContext) -> ToolResult:
+        tool = self._registry.get(tool_name)
+        if tool is None:
+            return _failure(f'Tool "{tool_name}" is not registered in the current registry.')
+        return await self._invoke(tool, raw_input, context)
+
+    async def execute_batch(
+        self, calls: list[BatchToolCall], context: ToolUseContext
+    ) -> dict[str, ToolResult]:
+        results: dict[str, ToolResult] = {}
+
+        async def _run(call: BatchToolCall) -> None:
+            result = await self._semaphore.run(lambda: self.execute(call.name, call.input, context))
+            results[call.id] = result
+
+        await asyncio.gather(*[_run(c) for c in calls])
+        return results
+
+    async def _invoke(self, tool: ToolDefinition, raw_input: dict[str, Any], context: ToolUseContext) -> ToolResult:
+        try:
+            validated = tool.input_model.model_validate(raw_input)
+        except Exception as e:
+            return _failure(f'Invalid input for tool "{tool.name}": {e}')
+
+        try:
+            return await tool.execute(validated, context)
+        except Exception as e:
+            return _failure(f'Tool "{tool.name}" raised an error: {e}')
+
+
+def _failure(message: str) -> ToolResult:
+    return ToolResult(data=message, is_error=True)

anycode/tools/file_edit.py

@@ -0,0 +1,70 @@
+"""Targeted string replacement tool — edits existing files in place."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from anycode.tools.registry import define_tool
+from anycode.types import ToolResult, ToolUseContext
+
+
+class FileEditInput(BaseModel):
+    path: str = Field(description="Absolute path of the target file.")
+    old_string: str = Field(description="The exact text to locate and replace.")
+    new_string: str = Field(description="The substitution text.")
+    replace_all: bool = Field(default=False, description="When true, replace every match.")
+
+
+async def _execute(input: FileEditInput, context: ToolUseContext) -> ToolResult:
+    try:
+        original = Path(input.path).read_text(encoding="utf-8")
+    except Exception as e:
+        return ToolResult(data=f'Unable to read "{input.path}": {e}', is_error=True)
+
+    hits = _tally(original, input.old_string)
+
+    if hits == 0:
+        return ToolResult(
+            data=f'The target string was not found in "{input.path}".\nVerify that old_string matches the file content exactly.',
+            is_error=True,
+        )
+
+    if hits > 1 and not input.replace_all:
+        return ToolResult(
+            data=f'old_string appears {hits} times in "{input.path}". Use a more specific string or set replace_all=True.',
+            is_error=True,
+        )
+
+    updated = original.replace(input.old_string, input.new_string) if input.replace_all else original.replace(input.old_string, input.new_string, 1)
+
+    try:
+        Path(input.path).write_text(updated, encoding="utf-8")
+    except Exception as e:
+        return ToolResult(data=f'Unable to write "{input.path}": {e}', is_error=True)
+
+    replaced = hits if input.replace_all else 1
+    return ToolResult(data=f'Replaced {replaced} occurrence{"s" if replaced != 1 else ""} in "{input.path}".', is_error=False)
+
+
+def _tally(source: str, search: str) -> int:
+    if not search:
+        return 0
+    count = 0
+    pos = 0
+    while True:
+        pos = source.find(search, pos)
+        if pos == -1:
+            break
+        count += 1
+        pos += len(search)
+    return count
+
+
+file_edit_tool = define_tool(
+    name="file_edit",
+    description="Modify a file by swapping a specific string with new content. The old_string must match verbatim within the file.",
+    input_model=FileEditInput,
+    execute=_execute,
+)

anycode/tools/file_read.py

@@ -0,0 +1,52 @@
+"""File reader tool — retrieves file contents with optional range windowing."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from anycode.tools.registry import define_tool
+from anycode.types import ToolResult, ToolUseContext
+
+
+class FileReadInput(BaseModel):
+    path: str = Field(description="Absolute path of the file to read.")
+    offset: int | None = Field(default=None, description="1-based starting line number.")
+    limit: int | None = Field(default=None, description="Maximum lines to return.")
+
+
+async def _execute(input: FileReadInput, context: ToolUseContext) -> ToolResult:
+    try:
+        raw = Path(input.path).read_text(encoding="utf-8")
+    except Exception as e:
+        return ToolResult(data=f'Unable to read "{input.path}": {e}', is_error=True)
+
+    lines = raw.split("\n")
+    if lines and lines[-1] == "":
+        lines.pop()
+
+    total = len(lines)
+    start = max(0, (input.offset or 1) - 1)
+
+    if start >= total > 0:
+        return ToolResult(
+            data=f'File "{input.path}" contains {total} line{"s" if total != 1 else ""} but offset {input.offset} exceeds the range.',
+            is_error=True,
+        )
+
+    end = min(start + input.limit, total) if input.limit else total
+    numbered = "\n".join(f"{start + i + 1}\t{line}" for i, line in enumerate(lines[start:end]))
+    meta = f"\n\n(showing lines {start + 1}\u2013{end} of {total})" if end < total else ""
+    return ToolResult(data=numbered + meta, is_error=False)
+
+
+file_read_tool = define_tool(
+    name="file_read",
+    description=(
+        "Retrieve the contents of a file from disk. Output includes line numbers in the format 'N\\t<line>'."
+        " Specify offset and limit to page through large files."
+    ),
+    input_model=FileReadInput,
+    execute=_execute,
+)

anycode/tools/file_write.py

@@ -0,0 +1,49 @@
+"""File writer tool — creates or replaces files, auto-creating parent directories."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from anycode.tools.registry import define_tool
+from anycode.types import ToolResult, ToolUseContext
+
+
+class FileWriteInput(BaseModel):
+    path: str = Field(description="Absolute path of the file to write.")
+    content: str = Field(description="Complete content to place in the file.")
+
+
+async def _execute(input: FileWriteInput, context: ToolUseContext) -> ToolResult:
+    target = Path(input.path)
+    existed = target.exists()
+
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        return ToolResult(data=f'Could not create parent directory "{target.parent}": {e}', is_error=True)
+
+    try:
+        target.write_text(input.content, encoding="utf-8")
+    except Exception as e:
+        return ToolResult(data=f'Could not write file "{input.path}": {e}', is_error=True)
+
+    line_count = input.content.count("\n") + (1 if input.content and not input.content.endswith("\n") else 0)
+    byte_count = len(input.content.encode("utf-8"))
+    action = "Overwrote" if existed else "Created"
+    return ToolResult(
+        data=f'{action} "{input.path}" ({line_count} line{"s" if line_count != 1 else ""}, {byte_count} bytes).',
+        is_error=False,
+    )
+
+
+file_write_tool = define_tool(
+    name="file_write",
+    description=(
+        "Write content to a file. Creates the file and any missing parent directories if it does not exist,"
+        " or overwrites the file if it does."
+    ),
+    input_model=FileWriteInput,
+    execute=_execute,
+)

anycode/tools/grep.py

@@ -0,0 +1,127 @@
+"""Regex search tool — ripgrep fast-path with Python fallback."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import shutil
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from anycode.tools.registry import define_tool
+from anycode.types import ToolResult, ToolUseContext
+
+MATCH_CEILING = 100
+IGNORED_DIRS = {".git", ".svn", ".hg", "node_modules", ".next", "dist", "build", "__pycache__", ".venv"}
+
+
+class GrepInput(BaseModel):
+    pattern: str = Field(description="Regex pattern to search for.")
+    path: str | None = Field(default=None, description="Directory or file to search. Defaults to cwd.")
+    glob: str | None = Field(default=None, description='Glob filter for filenames (e.g. "*.py").')
+    max_results: int = Field(default=MATCH_CEILING, description="Upper bound on matching lines.")
+
+
+async def _execute(input: GrepInput, context: ToolUseContext) -> ToolResult:
+    search_path = input.path or os.getcwd()
+    cap = input.max_results
+
+    try:
+        regex = re.compile(input.pattern)
+    except re.error:
+        return ToolResult(data=f'Invalid regex pattern: "{input.pattern}"', is_error=True)
+
+    if _has_ripgrep():
+        return await _ripgrep_search(input.pattern, search_path, glob=input.glob, max_results=cap)
+    return await _python_search(regex, search_path, glob=input.glob, max_results=cap)
+
+
+async def _ripgrep_search(
+    pattern: str, search_path: str, *, glob: str | None, max_results: int
+) -> ToolResult:
+    args = ["rg", "--line-number", "--no-heading", "--color=never", f"--max-count={max_results}"]
+    if glob:
+        args.extend(["--glob", glob])
+    args.extend(["--", pattern, search_path])
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        output = stdout.decode("utf-8", errors="replace").strip()
+        if proc.returncode not in (0, 1):
+            return ToolResult(data=f"ripgrep exited with code {proc.returncode}: {stderr.decode().strip()}", is_error=True)
+        return ToolResult(data=output or "No matches.", is_error=False)
+    except Exception as e:
+        return ToolResult(data=f"ripgrep error: {e}", is_error=True)
+
+
+async def _python_search(
+    regex: re.Pattern[str], search_path: str, *, glob: str | None, max_results: int
+) -> ToolResult:
+    target = Path(search_path)
+    try:
+        files = [target] if target.is_file() else list(_gather_files(target, glob))
+    except Exception as e:
+        return ToolResult(data=f'Cannot access "{search_path}": {e}', is_error=True)
+
+    hits: list[str] = []
+    for file in files:
+        if len(hits) >= max_results:
+            break
+        try:
+            content = file.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+        for i, line in enumerate(content.split("\n")):
+            if len(hits) >= max_results:
+                break
+            if regex.search(line):
+                rel = os.path.relpath(file) if file.is_absolute() else str(file)
+                hits.append(f"{rel}:{i + 1}:{line}")
+
+    if not hits:
+        return ToolResult(data="No matches.", is_error=False)
+    note = f"\n\n(results capped at {max_results} — increase max_results for more)" if len(hits) >= max_results else ""
+    return ToolResult(data="\n".join(hits) + note, is_error=False)
+
+
+def _gather_files(directory: Path, glob_pattern: str | None) -> list[Path]:
+    results: list[Path] = []
+    _traverse(directory, glob_pattern, results)
+    return results
+
+
+def _traverse(directory: Path, glob_pattern: str | None, results: list[Path]) -> None:
+    try:
+        entries = list(directory.iterdir())
+    except PermissionError:
+        return
+    for entry in entries:
+        if entry.is_dir():
+            if entry.name not in IGNORED_DIRS:
+                _traverse(entry, glob_pattern, results)
+        elif entry.is_file():
+            if glob_pattern is None or _glob_match(entry.name, glob_pattern):
+                results.append(entry)
+
+
+def _glob_match(filename: str, glob_pattern: str) -> bool:
+    pattern = glob_pattern.removeprefix("**/")
+    regex_src = re.escape(pattern).replace(r"\*", ".*").replace(r"\?", ".")
+    return bool(re.match(f"^{regex_src}$", filename, re.IGNORECASE))
+
+
+def _has_ripgrep() -> bool:
+    return shutil.which("rg") is not None
+
+
+grep_tool = define_tool(
+    name="grep",
+    description="Search files for a regular-expression pattern. Returns matching lines with file paths and line numbers.",
+    input_model=GrepInput,
+    execute=_execute,
+)

anycode/tools/registry.py

@@ -0,0 +1,84 @@
+"""Tool declaration, registration, and schema conversion."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from pydantic import BaseModel
+
+from anycode.types import LLMToolDef, ToolDefinition, ToolResult
+
+
+def define_tool(
+    *,
+    name: str,
+    description: str,
+    input_model: type[BaseModel],
+    execute: Callable[..., Awaitable[ToolResult]],
+) -> ToolDefinition:
+    """Create a typed tool definition."""
+    return ToolDefinition(name=name, description=description, input_model=input_model, execute=execute)
+
+
+class ToolRegistry:
+    """Named store that converts entries to JSON Schema for LLM providers."""
+
+    def __init__(self) -> None:
+        self._tools: dict[str, ToolDefinition] = {}
+
+    def register(self, tool: ToolDefinition) -> None:
+        if tool.name in self._tools:
+            raise ValueError(
+                f'ToolRegistry: "{tool.name}" is already registered. '
+                "Choose a unique name or remove the existing entry first."
+            )
+        self._tools[tool.name] = tool
+
+    def get(self, name: str) -> ToolDefinition | None:
+        return self._tools.get(name)
+
+    def list(self) -> list[ToolDefinition]:
+        return list(self._tools.values())
+
+    def has(self, name: str) -> bool:
+        return name in self._tools
+
+    def deregister(self, name: str) -> None:
+        self._tools.pop(name, None)
+
+    def to_tool_defs(self) -> list[LLMToolDef]:
+        return [
+            LLMToolDef(
+                name=tool.name,
+                description=tool.description,
+                input_schema=_model_to_json_schema(tool.input_model),
+            )
+            for tool in self._tools.values()
+        ]
+
+    def to_llm_tools(self) -> list[dict[str, Any]]:
+        """Anthropic-specific format with input_schema."""
+        result = []
+        for tool in self._tools.values():
+            schema = _model_to_json_schema(tool.input_model)
+            result.append({
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": {
+                    "type": "object",
+                    "properties": schema.get("properties", {}),
+                    **({"required": schema["required"]} if "required" in schema else {}),
+                },
+            })
+        return result
+
+
+def _model_to_json_schema(model: type[BaseModel]) -> dict[str, Any]:
+    """Convert a Pydantic model to JSON Schema suitable for LLM tool definitions."""
+    schema = model.model_json_schema()
+    # Remove pydantic metadata fields not needed by LLMs
+    schema.pop("title", None)
+    for prop in schema.get("properties", {}).values():
+        prop.pop("title", None)
+    return schema