pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/utils/path.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+from collections.abc import Sequence
+from pathlib import Path, PurePath
+from stat import S_ISDIR
+
+import aiofiles.os
+from pythinker_host.path import HostPath
+
+_ROTATION_OPEN_FLAGS = os.O_CREAT | os.O_EXCL | os.O_WRONLY
+_ROTATION_FILE_MODE = 0o600
+
+
+async def _reserve_rotation_path(path: Path) -> bool:
+    """Atomically create an empty file as a reservation for *path*."""
+
+    def _create() -> None:
+        fd = os.open(str(path), _ROTATION_OPEN_FLAGS, _ROTATION_FILE_MODE)
+        os.close(fd)
+
+    try:
+        await asyncio.to_thread(_create)
+    except FileExistsError:
+        return False
+    return True
+
+
+async def next_available_rotation(path: Path) -> Path | None:
+    """Return a reserved rotation path for *path* or ``None`` if parent is missing.
+
+    The caller must overwrite/reuse the returned path immediately because this helper
+    commits an empty placeholder file to guarantee uniqueness. It is therefore suited
+    for rotating *files* (like history logs) but **not** directory creation.
+    """
+
+    if not path.parent.exists():
+        return None
+
+    base_name = path.stem
+    suffix = path.suffix
+    pattern = re.compile(rf"^{re.escape(base_name)}_(\d+){re.escape(suffix)}$")
+    max_num = 0
+    for entry in await aiofiles.os.listdir(path.parent):
+        if match := pattern.match(entry):
+            max_num = max(max_num, int(match.group(1)))
+
+    next_num = max_num + 1
+    while True:
+        next_path = path.parent / f"{base_name}_{next_num}{suffix}"
+        if await _reserve_rotation_path(next_path):
+            return next_path
+        next_num += 1
+
+
+_LIST_DIR_ROOT_WIDTH = 30  # worst-case ~330 lines ≈ 2.5k tokens
+_LIST_DIR_CHILD_WIDTH = 10
+
+
+async def _collect_entries(
+    dir_path: HostPath, max_width: int
+) -> tuple[list[tuple[str, bool]], int]:
+    """Collect up to *max_width* entries from *dir_path*.
+
+    Returns ``(entries, total_count)`` where each entry is ``(name, is_dir)``.
+    All entries are stat-ed, sorted directories-first then alphabetically,
+    and truncated to *max_width* so the returned subset is deterministic
+    regardless of filesystem enumeration order.
+    """
+    all_entries: list[tuple[str, bool]] = []
+    async for entry in dir_path.iterdir():
+        try:
+            st = await entry.stat()
+            is_dir = S_ISDIR(st.st_mode)
+        except OSError:
+            is_dir = False
+        all_entries.append((entry.name, is_dir))
+    all_entries.sort(key=lambda e: (not e[1], e[0]))
+    return all_entries[:max_width], len(all_entries)
+
+
+async def list_directory(work_dir: HostPath) -> str:
+    """Return a compact tree listing of *work_dir* (up to 2 levels).
+
+    This helper is used mainly to provide context to the LLM (for example
+    ``PYTHINKER_WORK_DIR_LS``) and to show top-level directory contents in tools.
+
+    Both depth and width are capped to keep the system-prompt token budget
+    bounded (see GH-1809):
+
+    * **Depth 0** (root): up to :data:`_LIST_DIR_ROOT_WIDTH` entries.
+    * **Depth 1** (children of root dirs): up to :data:`_LIST_DIR_CHILD_WIDTH`
+      entries per directory.
+    * Truncated levels show ``... and N more`` so the LLM knows more exists.
+    """
+    lines: list[str] = []
+    entries, total = await _collect_entries(work_dir, _LIST_DIR_ROOT_WIDTH)
+    remaining = total - len(entries)
+
+    for i, (name, is_dir) in enumerate(entries):
+        is_last = (i == len(entries) - 1) and remaining == 0
+        connector = "└── " if is_last else "├── "
+
+        if is_dir:
+            lines.append(f"{connector}{name}/")
+            child_prefix = "    " if is_last else "│   "
+            try:
+                child_entries, child_total = await _collect_entries(
+                    work_dir / name, _LIST_DIR_CHILD_WIDTH
+                )
+            except OSError:
+                lines.append(f"{child_prefix}└── [not readable]")
+                continue
+            child_remaining = child_total - len(child_entries)
+            for j, (child_name, child_is_dir) in enumerate(child_entries):
+                child_is_last = (j == len(child_entries) - 1) and child_remaining == 0
+                child_connector = "└── " if child_is_last else "├── "
+                suffix = "/" if child_is_dir else ""
+                lines.append(f"{child_prefix}{child_connector}{child_name}{suffix}")
+            if child_remaining > 0:
+                lines.append(f"{child_prefix}└── ... and {child_remaining} more")
+        else:
+            lines.append(f"{connector}{name}")
+
+    if remaining > 0:
+        lines.append(f"└── ... and {remaining} more entries")
+
+    return "\n".join(lines) if lines else "(empty directory)"
+
+
+def shorten_home(path: HostPath) -> HostPath:
+    """
+    Convert absolute path to use `~` for home directory.
+    """
+    try:
+        home = HostPath.home()
+        p = path.relative_to(home)
+        return HostPath("~") / p
+    except Exception:
+        return path
+
+
+def sanitize_cli_path(raw: str) -> str:
+    """Strip surrounding quotes from a CLI path argument.
+
+    On macOS, dragging a file into the terminal wraps the path in single
+    quotes (e.g. ``'/path/to/file'``).  This helper strips matching outer
+    quotes (single or double) so downstream path handling works correctly.
+    """
+    raw = raw.strip()
+    if len(raw) >= 2 and ((raw[0] == "'" and raw[-1] == "'") or (raw[0] == '"' and raw[-1] == '"')):
+        raw = raw[1:-1]
+    return raw
+
+
+def is_within_directory(path: HostPath, directory: HostPath) -> bool:
+    """
+    Check whether *path* is contained within *directory* using pure path semantics.
+    Both arguments should already be canonicalized (e.g. via HostPath.canonical()).
+    """
+    candidate = PurePath(str(path))
+    base = PurePath(str(directory))
+    try:
+        candidate.relative_to(base)
+        return True
+    except ValueError:
+        return False
+
+
+def is_within_workspace(
+    path: HostPath,
+    work_dir: HostPath,
+    additional_dirs: Sequence[HostPath] = (),
+) -> bool:
+    """
+    Check whether *path* is within the workspace (work_dir or any additional directory).
+    """
+    if is_within_directory(path, work_dir):
+        return True
+    return any(is_within_directory(path, d) for d in additional_dirs)
+
+
+async def find_project_root(work_dir: HostPath) -> HostPath:
+    """Walk up from *work_dir* to find the nearest directory containing ``.git``.
+
+    Returns *work_dir* itself if no ``.git`` marker is found before reaching the
+    filesystem root. Used by AGENTS.md discovery and by resolving relative
+    ``extra_skill_dirs`` entries to the project root (not the CWD).
+    """
+    current = work_dir
+    while True:
+        if await (current / ".git").exists():
+            return current
+        parent = current.parent
+        if parent == current:  # filesystem root
+            return work_dir
+        current = parent

pythinker_code/utils/proctitle.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import sys
+
+
+def set_process_title(title: str) -> None:
+    """Set the OS-level process title visible in ps/top/terminal panels."""
+    try:
+        import setproctitle
+
+        setproctitle.setproctitle(title)
+    except ImportError:
+        pass
+
+
+def set_terminal_title(title: str) -> None:
+    """Set the terminal tab/window title via ANSI OSC escape sequence.
+
+    Only writes when stderr is a TTY to avoid polluting piped output.
+    """
+    if not sys.stderr.isatty():
+        return
+    try:
+        sys.stderr.write(f"\033]0;{title}\007")
+        sys.stderr.flush()
+    except OSError:
+        pass
+
+
+def init_process_name(name: str = "Pythinker") -> None:
+    """Initialize process name: OS process title + terminal tab title."""
+    set_process_title(name)
+    set_terminal_title(name)

pythinker_code/utils/proxy.py

@@ -0,0 +1,31 @@
+"""Normalize proxy environment variables for httpx/aiohttp compatibility."""
+
+from __future__ import annotations
+
+import os
+
+_PROXY_ENV_VARS = (
+    "ALL_PROXY",
+    "all_proxy",
+    "HTTP_PROXY",
+    "http_proxy",
+    "HTTPS_PROXY",
+    "https_proxy",
+)
+
+_SOCKS_PREFIX = "socks://"
+_SOCKS5_PREFIX = "socks5://"
+
+
+def normalize_proxy_env() -> None:
+    """Rewrite ``socks://`` to ``socks5://`` in proxy environment variables.
+
+    Many proxy tools (V2RayN, Clash, etc.) set ``ALL_PROXY=socks://...``, but
+    httpx and aiohttp only recognise ``socks5://``.  Since ``socks://`` is
+    effectively an alias for ``socks5://``, this function performs a safe
+    in-place replacement so that downstream HTTP clients work correctly.
+    """
+    for var in _PROXY_ENV_VARS:
+        value = os.environ.get(var)
+        if value is not None and value.lower().startswith(_SOCKS_PREFIX):
+            os.environ[var] = _SOCKS5_PREFIX + value[len(_SOCKS_PREFIX) :]

pythinker_code/utils/pyinstaller.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+
+from pythinker_code.cli._lazy_group import LazySubcommandGroup
+
+lazy_cli_hiddenimports = [
+    module_name
+    for module_name, _attribute_name, _help_text in (LazySubcommandGroup.lazy_subcommands.values())
+]
+
+hiddenimports = (
+    collect_submodules("pythinker_code.tools")
+    + lazy_cli_hiddenimports
+    # `cli/__init__.py` resolves _lazy_group via `import_module(f"{__name__}._lazy_group")`,
+    # which PyInstaller's static analysis can't follow.
+    + ["pythinker_code.cli._lazy_group", "setproctitle"]
+)
+datas = (
+    collect_data_files(
+        "pythinker_code",
+        includes=[
+            "agents/**/*.yaml",
+            "agents/**/*.md",
+            "deps/bin/**",
+            "prompts/**/*.md",
+            "skills/**",
+            "tools/**/*.md",
+            "web/static/**",
+            "vis/static/**",
+            "CHANGELOG.md",
+        ],
+        excludes=[
+            "tools/*.md",
+        ],
+    )
+    + collect_data_files(
+        "dateparser",
+        includes=["**/*.pkl"],
+    )
+    + collect_data_files(
+        "fastmcp",
+        includes=["../fastmcp-*.dist-info/*"],
+    )
+)

pythinker_code/utils/rich/__init__.py

@@ -0,0 +1,33 @@
+"""Project-wide Rich configuration helpers."""
+
+from __future__ import annotations
+
+import re
+from typing import Final
+
+from rich import _wrap
+
+# Regex used by Rich to compute break opportunities during wrapping.
+_DEFAULT_WRAP_PATTERN: Final[re.Pattern[str]] = re.compile(r"\s*\S+\s*")
+_CHAR_WRAP_PATTERN: Final[re.Pattern[str]] = re.compile(r".", re.DOTALL)
+
+
+def enable_character_wrap() -> None:
+    """Switch Rich's wrapping logic to break on every character.
+
+    Rich's default behavior tries to preserve whole words; we override the
+    internal regex so markdown rendering can fold text at any column once it
+    exceeds the terminal width.
+    """
+
+    _wrap.re_word = _CHAR_WRAP_PATTERN
+
+
+def restore_word_wrap() -> None:
+    """Restore Rich's default word-based wrapping."""
+
+    _wrap.re_word = _DEFAULT_WRAP_PATTERN
+
+
+# Apply character-based wrapping globally for the CLI.
+enable_character_wrap()

pythinker_code/utils/rich/columns.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from rich.columns import Columns
+from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+from rich.measure import Measurement
+from rich.segment import Segment
+from rich.text import Text
+
+
+class _ShrinkToWidth:
+    def __init__(self, renderable: RenderableType, max_width: int) -> None:
+        self._renderable = renderable
+        self._max_width = max(max_width, 1)
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        width = self._resolve_width(options)
+        return Measurement(0, width)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        width = self._resolve_width(options)
+        child_options = options.update(width=width)
+        yield from console.render(self._renderable, child_options)
+
+    def _resolve_width(self, options: ConsoleOptions) -> int:
+        return max(1, min(self._max_width, options.max_width))
+
+
+def _strip_trailing_spaces(segments: list[Segment]) -> list[Segment]:
+    lines = list(Segment.split_lines(segments))
+    trimmed: list[Segment] = []
+    n_lines = len(lines)
+    for index, line in enumerate(lines):
+        line_segments = list(line)
+        while line_segments:
+            segment = line_segments[-1]
+            if segment.control is not None:
+                break
+            trimmed_text = segment.text.rstrip(" ")
+            if trimmed_text != segment.text:
+                if trimmed_text:
+                    line_segments[-1] = Segment(trimmed_text, segment.style, segment.control)
+                    break
+                line_segments.pop()
+                continue
+            break
+        trimmed.extend(line_segments)
+        if index != n_lines - 1:
+            trimmed.append(Segment.line())
+    if trimmed:
+        trimmed.append(Segment.line())
+    return trimmed
+
+
+class BulletColumns:
+    def __init__(
+        self,
+        renderable: RenderableType,
+        *,
+        bullet_style: str | None = None,
+        bullet: RenderableType | None = None,
+        padding: int = 1,
+    ) -> None:
+        self._renderable = renderable
+        self._bullet = bullet
+        self._bullet_style = bullet_style
+        self._padding = padding
+
+    def _bullet_renderable(self) -> RenderableType:
+        if self._bullet is not None:
+            return self._bullet
+        return Text("•", style=self._bullet_style or "")
+
+    def _available_width(self, console: Console, options: ConsoleOptions, bullet_width: int) -> int:
+        max_width = options.max_width or console.width or (bullet_width + self._padding + 1)
+        available = max_width - bullet_width - self._padding
+        return max(available, 1)
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        bullet = self._bullet_renderable()
+        bullet_measure = Measurement.get(console, options, bullet)
+        bullet_width = max(bullet_measure.maximum, 1)
+        available = self._available_width(console, options, bullet_width)
+        constrained = _ShrinkToWidth(self._renderable, available)
+        columns = Columns([bullet, constrained], expand=False, padding=(0, self._padding))
+        return Measurement.get(console, options, columns)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        bullet = self._bullet_renderable()
+        bullet_measure = Measurement.get(console, options, bullet)
+        bullet_width = max(bullet_measure.maximum, 1)
+        available = self._available_width(console, options, bullet_width)
+        columns = Columns(
+            [bullet, _ShrinkToWidth(self._renderable, available)],
+            expand=False,
+            padding=(0, self._padding),
+        )
+        segments = list(console.render(columns, options))
+        trimmed = _strip_trailing_spaces(segments)
+        yield from trimmed