python-codex 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

pycodex/tools/exec_runtime.js

@@ -0,0 +1,161 @@
+const readline = require('node:readline');
+const { stdin, stdout } = require('node:process');
+
+const pending = new Map();
+let storedValues = {};
+let toolMap = {};
+let initialized = false;
+
+function send(message) {
+  stdout.write(JSON.stringify(message) + '\n');
+}
+
+function stringifyValue(value) {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (value === undefined) {
+    return 'undefined';
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (_error) {
+    return String(value);
+  }
+}
+
+function text(value) {
+  send({ type: 'output_text', text: stringifyValue(value) });
+}
+
+function notify(value) {
+  text(value);
+}
+
+function image(value) {
+  if (typeof value === 'string') {
+    send({ type: 'output_image', image_url: value, detail: null });
+    return;
+  }
+  if (value && typeof value === 'object' && typeof value.image_url === 'string') {
+    send({
+      type: 'output_image',
+      image_url: value.image_url,
+      detail: value.detail ?? null,
+    });
+    return;
+  }
+  throw new Error('image(...) expects an image URL string or { image_url, detail? }');
+}
+
+function store(key, value) {
+  storedValues[key] = value;
+}
+
+function load(key) {
+  return storedValues[key];
+}
+
+function exit() {
+  const error = new Error('__CODEX_EXIT__');
+  error.__codexExit = true;
+  throw error;
+}
+
+async function yield_control() {
+  send({ type: 'yield' });
+}
+
+function createToolCaller(toolName) {
+  return function callTool(argumentsValue = {}) {
+    const id = `${toolName}_${Math.random().toString(16).slice(2)}`;
+    send({
+      type: 'tool_call',
+      id,
+      tool_name: toolName,
+      arguments: argumentsValue,
+    });
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+    });
+  };
+}
+
+function initialize(message) {
+  storedValues = message.stored_values || {};
+  toolMap = {};
+  for (const tool of message.tools || []) {
+    toolMap[tool.js_name] = createToolCaller(tool.tool_name);
+  }
+  const allTools = Object.freeze(
+    (message.tools || []).map((tool) => ({
+      name: tool.js_name,
+      description: tool.description,
+    }))
+  );
+
+  const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+  const fn = new AsyncFunction(
+    'tools',
+    'text',
+    'image',
+    'store',
+    'load',
+    'exit',
+    'notify',
+    'ALL_TOOLS',
+    'yield_control',
+    'console',
+    message.source
+  );
+
+  (async () => {
+    try {
+      await fn(
+        toolMap,
+        text,
+        image,
+        store,
+        load,
+        exit,
+        notify,
+        allTools,
+        yield_control,
+        undefined
+      );
+      send({ type: 'result', stored_values: storedValues, error_text: null });
+    } catch (error) {
+      if (error && error.__codexExit) {
+        send({ type: 'result', stored_values: storedValues, error_text: null });
+        return;
+      }
+      const errorText = error && error.stack ? error.stack : String(error);
+      send({ type: 'result', stored_values: storedValues, error_text: errorText });
+    }
+  })();
+}
+
+const rl = readline.createInterface({ input: stdin, crlfDelay: Infinity });
+rl.on('line', (line) => {
+  if (!line.trim()) {
+    return;
+  }
+  const message = JSON.parse(line);
+  if (message.type === 'init' && !initialized) {
+    initialized = true;
+    initialize(message);
+    return;
+  }
+  if (message.type === 'tool_result') {
+    const entry = pending.get(message.id);
+    if (!entry) {
+      return;
+    }
+    pending.delete(message.id);
+    if (message.ok) {
+      entry.resolve(message.result);
+    } else {
+      entry.reject(new Error(message.error || 'nested tool failed'));
+    }
+  }
+});

pycodex/tools/exec_tool.py

@@ -0,0 +1,48 @@
+"""`exec` tool for the Python Codex prototype.
+
+Original Codex mapping:
+- Corresponds to the original Codex code-mode `exec` tool.
+
+Expected behavior:
+- Accept raw JavaScript source text as a freeform/custom tool payload.
+- Run the script inside a background exec cell with helper functions and nested
+  tool access.
+- Return either a completed result or a running `cell_id` status that can be
+  resumed via `wait`.
+"""
+
+from __future__ import annotations
+
+from ..protocol import JSONValue
+from .base_tool import BaseTool, ToolContext
+from .code_mode_manager import CodeModeManager
+
+EXEC_FREEFORM_GRAMMAR = """start: pragma_source | plain_source
+pragma_source: PRAGMA_LINE NEWLINE SOURCE
+plain_source: SOURCE
+
+PRAGMA_LINE: /[ \t]*\/\/ @exec:[^\r\n]*/
+NEWLINE: /\r?\n/
+SOURCE: /[\s\S]+/
+"""
+
+
+class ExecTool(BaseTool):
+    name = "exec"
+    description = (
+        "Runs raw JavaScript in an isolated context. Send raw JavaScript "
+        "source text, not JSON, quoted strings, or markdown code fences."
+    )
+    tool_type = "custom"
+    format = {
+        "type": "grammar",
+        "syntax": "lark",
+        "definition": EXEC_FREEFORM_GRAMMAR,
+    }
+    supports_parallel = False
+
+    def __init__(self, manager: CodeModeManager) -> None:
+        self._manager = manager
+
+    async def run(self, context: ToolContext, args: JSONValue) -> JSONValue:
+        return await self._manager.exec(str(args), context)

pycodex/tools/grep_files_tool.py

@@ -0,0 +1,150 @@
+"""`grep_files` tool for the Python Codex prototype.
+
+Original Codex mapping:
+- Corresponds to the original Codex `grep_files` tool.
+
+Expected behavior:
+- Search file contents with ripgrep and return only matching file paths.
+- Support the original tool's `pattern`, `include`, `path`, and `limit`
+  parameters rather than delegating to a shell transcript.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+import re
+from pathlib import Path
+
+from ..protocol import JSONDict, JSONValue
+from .base_tool import BaseTool, ToolContext
+
+DEFAULT_LIMIT = 100
+MAX_LIMIT = 2000
+COMMAND_TIMEOUT_SECONDS = 30
+
+
+class GrepFilesTool(BaseTool):
+    name = "grep_files"
+    description = (
+        "Finds files whose contents match the pattern and lists them by "
+        "modification time."
+    )
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {"type": "string"},
+            "include": {"type": "string"},
+            "path": {"type": "string"},
+            "limit": {"type": "integer"},
+        },
+        "required": ["pattern"],
+    }
+
+    def __init__(self, cwd: str | Path | None = None) -> None:
+        self._working_directory = Path(cwd or Path.cwd()).resolve()
+
+    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+        del context
+        pattern = str(args.get("pattern", "")).strip()
+        include = str(args.get("include", "")).strip() or None
+        limit = min(int(args.get("limit", DEFAULT_LIMIT)), MAX_LIMIT)
+        path_arg = args.get("path")
+        search_path = self._resolve_path(path_arg)
+
+        if not pattern:
+            return "Error: `pattern` must not be empty."
+        if limit <= 0:
+            return "Error: `limit` must be greater than zero."
+        if not search_path.exists():
+            return f"Error: unable to access `{search_path}`."
+
+        command = [
+            "rg",
+            "--files-with-matches",
+            "--sortr=modified",
+            "--regexp",
+            pattern,
+            "--no-messages",
+        ]
+        if include is not None:
+            command.extend(["--glob", include])
+        command.extend(["--", str(search_path)])
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *command,
+                cwd=str(self._working_directory),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+        except FileNotFoundError:
+            results = self._search_with_python(pattern, include, search_path, limit)
+            if not results:
+                return "No matches found."
+            return "\n".join(results)
+
+        try:
+            stdout_bytes, stderr_bytes = await asyncio.wait_for(
+                process.communicate(),
+                timeout=COMMAND_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            process.kill()
+            await process.communicate()
+            return "Error: rg timed out after 30 seconds."
+
+        if process.returncode == 1:
+            return "No matches found."
+        if process.returncode != 0:
+            stderr = stderr_bytes.decode("utf-8", errors="replace").strip()
+            return f"Error: rg failed: {stderr}"
+
+        results = [
+            line
+            for line in stdout_bytes.decode("utf-8", errors="replace").splitlines()
+            if line.strip()
+        ][:limit]
+        if not results:
+            return "No matches found."
+        return "\n".join(results)
+
+    def _search_with_python(
+        self,
+        pattern: str,
+        include: str | None,
+        search_path: Path,
+        limit: int,
+    ) -> list[str]:
+        regex = re.compile(pattern)
+        candidates: list[Path] = []
+
+        if search_path.is_file():
+            candidates = [search_path]
+        else:
+            candidates = [path for path in search_path.rglob("*") if path.is_file()]
+
+        if include is not None:
+            candidates = [
+                path for path in candidates if fnmatch.fnmatch(path.name, include)
+            ]
+
+        matches = []
+        for path in candidates:
+            try:
+                text = path.read_text(errors="replace")
+            except OSError:
+                continue
+            if regex.search(text):
+                matches.append(path)
+
+        matches.sort(key=lambda path: path.stat().st_mtime, reverse=True)
+        return [str(path) for path in matches[:limit]]
+
+    def _resolve_path(self, path_arg) -> Path:
+        if path_arg in (None, ""):
+            return self._working_directory
+        path = Path(str(path_arg))
+        if not path.is_absolute():
+            path = self._working_directory / path
+        return path.resolve()

pycodex/tools/list_dir_tool.py

@@ -0,0 +1,135 @@
+"""`list_dir` tool for the Python Codex prototype.
+
+Original Codex mapping:
+- Corresponds to the original Codex `list_dir` tool.
+
+Expected behavior:
+- List directory entries from an absolute path with offset/limit/depth controls.
+- Produce a stable, human-readable directory tree slice instead of using shell
+  commands like `find` or `ls -R`.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from pathlib import Path
+
+from ..protocol import JSONDict, JSONValue
+from .base_tool import BaseTool, ToolContext
+
+MAX_ENTRY_LENGTH = 500
+INDENTATION_SPACES = 2
+
+
+class ListDirTool(BaseTool):
+    name = "list_dir"
+    description = (
+        "Lists entries in a local directory with 1-indexed entry numbers and "
+        "simple type labels."
+    )
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "dir_path": {"type": "string"},
+            "offset": {"type": "integer"},
+            "limit": {"type": "integer"},
+            "depth": {"type": "integer"},
+        },
+        "required": ["dir_path"],
+    }
+
+    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+        del context
+        dir_path = Path(str(args.get("dir_path", "")))
+        offset = int(args.get("offset", 1))
+        limit = int(args.get("limit", 25))
+        depth = int(args.get("depth", 2))
+
+        if not dir_path.is_absolute():
+            return "Error: `dir_path` must be an absolute path."
+        if offset <= 0:
+            return "Error: `offset` must be a 1-indexed entry number."
+        if limit <= 0:
+            return "Error: `limit` must be greater than zero."
+        if depth <= 0:
+            return "Error: `depth` must be greater than zero."
+        if not dir_path.exists():
+            return f"Error: `{dir_path}` does not exist."
+        if not dir_path.is_dir():
+            return f"Error: `{dir_path}` is not a directory."
+
+        entries = self._collect_entries(dir_path, depth)
+        if not entries:
+            return f"Absolute path: {dir_path}"
+
+        start_index = offset - 1
+        if start_index >= len(entries):
+            return "Error: `offset` exceeds directory entry count."
+
+        end_index = min(start_index + limit, len(entries))
+        selected = entries[start_index:end_index]
+        lines = [f"Absolute path: {dir_path}"]
+        lines.extend(self._format_entry_line(entry) for entry in selected)
+        if end_index < len(entries):
+            lines.append(f"More than {len(selected)} entries found")
+        return "\n".join(lines)
+
+    def _collect_entries(self, root: Path, depth: int) -> list[dict[str, object]]:
+        entries: list[dict[str, object]] = []
+        queue = deque([(root, Path(), depth)])
+
+        while queue:
+            current_dir, prefix, remaining_depth = queue.popleft()
+            dir_entries = []
+            for child in current_dir.iterdir():
+                relative_path = prefix / child.name if prefix.parts else Path(child.name)
+                kind = self._entry_kind(child)
+                dir_entries.append(
+                    (
+                        child,
+                        relative_path,
+                        {
+                            "name": self._format_entry_name(relative_path),
+                            "display_name": self._format_component(child.name),
+                            "depth": len(prefix.parts),
+                            "kind": kind,
+                        },
+                    )
+                )
+
+            dir_entries.sort(key=lambda item: item[2]["name"])
+            for child, relative_path, entry in dir_entries:
+                if entry["kind"] == "directory" and remaining_depth > 1:
+                    queue.append((child, relative_path, remaining_depth - 1))
+                entries.append(entry)
+
+        entries.sort(key=lambda entry: entry["name"])
+        return entries
+
+    def _entry_kind(self, path: Path) -> str:
+        if path.is_symlink():
+            return "symlink"
+        if path.is_dir():
+            return "directory"
+        if path.is_file():
+            return "file"
+        return "other"
+
+    def _format_entry_name(self, path: Path) -> str:
+        text = path.as_posix()
+        return text[:MAX_ENTRY_LENGTH]
+
+    def _format_component(self, name: str) -> str:
+        return name[:MAX_ENTRY_LENGTH]
+
+    def _format_entry_line(self, entry: dict[str, object]) -> str:
+        indent = " " * (int(entry["depth"]) * INDENTATION_SPACES)
+        name = str(entry["display_name"])
+        kind = str(entry["kind"])
+        if kind == "directory":
+            name += "/"
+        elif kind == "symlink":
+            name += "@"
+        elif kind == "other":
+            name += "?"
+        return f"{indent}{name}"