pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/utils/rich/markdown_sample.md

@@ -0,0 +1,108 @@
+# Markdown Sample Document
+
+This is a comprehensive sample document showcasing various Markdown elements.
+
+## Level 2 Heading
+
+### Level 3 Heading
+
+Here's some regular text with **bold text**, *italic text*, and `inline code`.
+
+## Lists
+
+### Unordered List
+
+- First item
+- Second item
+  - Nested item 1
+  - Nested item 2
+- Third item
+
+### Ordered List
+
+1. First step
+2. Second step
+   1. Sub-step A
+   2. Sub-step B
+3. Third step
+
+### Mixed List
+
+1. First item
+   - Sub-item with bullet
+   - Another sub-item
+2. Second item
+   1. Numbered sub-item
+   2. Another numbered sub-item
+
+## Links and References
+
+Here's a [link to GitHub](https://github.com) and another [relative link](../README.md).
+
+## Code Blocks
+
+```python
+def hello_world():
+    """A simple function to demonstrate code blocks."""
+    print("Hello, World!")
+    return 42
+
+# Call the function
+result = hello_world()
+```
+
+```bash
+# Bash example
+echo "This is a bash script"
+ls -la /tmp
+```
+
+## Blockquotes
+
+> This is a blockquote.
+> It can span multiple lines.
+>
+> > And it can be nested too!
+
+## Tables
+
+| Column 1 | Column 2 | Column 3 |
+|----------|----------|----------|
+| Cell 1   | Cell 2   | Cell 3   |
+| Left     | Center   | Right    |
+| Foo      | Bar      | Baz      |
+
+## Horizontal Rules
+
+---
+
+Here's some text after a horizontal rule.
+
+---
+
+## Inline Formatting
+
+You can combine **bold and *italic*** text, or use `code` within paragraphs.
+
+**Important**: Always test your `code` snippets before deployment.
+
+## Advanced Features
+
+### Task Lists
+
+- [x] Completed task
+- [ ] Pending task
+- [ ] Another pending task
+
+### Definition Lists
+
+Term 1
+: Definition of term 1
+
+Term 2
+: Definition of term 2
+: Another definition for term 2
+
+---
+
+*This document demonstrates comprehensive Markdown formatting capabilities.*

pythinker_code/utils/rich/markdown_sample_short.md

@@ -0,0 +1,2 @@
+- First
+- Second

pythinker_code/utils/rich/syntax.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pygments.token import (
+    Comment,
+    Generic,
+    Keyword,
+    Name,
+    Number,
+    Operator,
+    Punctuation,
+    String,
+)
+from pygments.token import (
+    Literal as PygmentsLiteral,
+)
+from pygments.token import (
+    Text as PygmentsText,
+)
+from pygments.token import (
+    Token as PygmentsToken,
+)
+from rich.style import Style
+from rich.syntax import ANSISyntaxTheme, Syntax, SyntaxTheme
+
+PYTHINKER_ANSI_THEME_NAME = "pythinker-ansi"
+PYTHINKER_ANSI_THEME = ANSISyntaxTheme(
+    {
+        PygmentsToken: Style(color="default"),
+        PygmentsText: Style(color="default"),
+        Comment: Style(color="bright_black", italic=True),
+        Keyword: Style(color="magenta"),
+        Keyword.Constant: Style(color="cyan"),
+        Keyword.Declaration: Style(color="magenta"),
+        Keyword.Namespace: Style(color="magenta"),
+        Keyword.Pseudo: Style(color="magenta"),
+        Keyword.Reserved: Style(color="magenta"),
+        Keyword.Type: Style(color="magenta"),
+        Name: Style(color="default"),
+        Name.Attribute: Style(color="cyan"),
+        Name.Builtin: Style(color="bright_yellow"),
+        Name.Builtin.Pseudo: Style(color="cyan"),
+        Name.Builtin.Type: Style(color="bright_yellow", bold=True),
+        Name.Class: Style(color="bright_yellow", bold=True),
+        Name.Constant: Style(color="cyan"),
+        Name.Decorator: Style(color="bright_cyan"),
+        Name.Entity: Style(color="bright_yellow"),
+        Name.Exception: Style(color="bright_yellow", bold=True),
+        Name.Function: Style(color="bright_cyan"),
+        Name.Label: Style(color="cyan"),
+        Name.Namespace: Style(color="magenta"),
+        Name.Other: Style(color="bright_cyan"),
+        Name.Property: Style(color="cyan"),
+        Name.Tag: Style(color="bright_green"),
+        Name.Variable: Style(color="bright_yellow"),
+        PygmentsLiteral: Style(color="bright_blue"),
+        PygmentsLiteral.Date: Style(color="bright_blue"),
+        String: Style(color="bright_blue"),
+        String.Doc: Style(color="bright_blue", italic=True),
+        String.Interpol: Style(color="bright_blue"),
+        String.Affix: Style(color="cyan"),
+        Number: Style(color="cyan"),
+        Operator: Style(color="default"),
+        Operator.Word: Style(color="magenta"),
+        Punctuation: Style(color="default"),
+        Generic.Deleted: Style(color="red"),
+        Generic.Emph: Style(italic=True),
+        Generic.Error: Style(color="bright_red", bold=True),
+        Generic.Heading: Style(color="cyan", bold=True),
+        Generic.Inserted: Style(color="green"),
+        Generic.Output: Style(color="bright_black"),
+        Generic.Prompt: Style(color="bright_cyan"),
+        Generic.Strong: Style(bold=True),
+        Generic.Subheading: Style(color="cyan"),
+        Generic.Traceback: Style(color="bright_red", bold=True),
+    }
+)
+
+
+def resolve_code_theme(theme: str | SyntaxTheme) -> str | SyntaxTheme:
+    if isinstance(theme, str) and theme.lower() == PYTHINKER_ANSI_THEME_NAME:
+        return PYTHINKER_ANSI_THEME
+    return theme
+
+
+class PythinkerSyntax(Syntax):
+    def __init__(self, code: str, lexer: str, **kwargs: Any) -> None:
+        if "theme" not in kwargs or kwargs["theme"] is None:
+            kwargs["theme"] = PYTHINKER_ANSI_THEME
+        super().__init__(code, lexer, **kwargs)
+
+
+if __name__ == "__main__":
+    from rich.console import Console
+    from rich.text import Text
+
+    console = Console()
+
+    examples = [
+        ("diff", "diff", "@@ -1,2 +1,2 @@\n-line one\n+line uno\n"),
+        (
+            "python",
+            "python",
+            'def greet(name: str) -> str:\n    return f"Hi, {name}!"\n',
+        ),
+        ("bash", "bash", "set -euo pipefail\nprintf '%s\\n' \"hello\"\n"),
+    ]
+
+    for idx, (title, lexer, code) in enumerate(examples):
+        if idx:
+            console.print()
+        console.print(Text(f"[{title}]", style="bold"))
+        console.print(PythinkerSyntax(code, lexer))

pythinker_code/utils/sensitive.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import fnmatch
+from pathlib import PurePath
+
+# High-confidence sensitive file patterns.
+# Only patterns with very low false-positive risk are included.
+SENSITIVE_PATTERNS: list[str] = [
+    # Environment variable / secrets
+    ".env",
+    ".env.*",
+    # SSH private keys
+    "id_rsa",
+    "id_ed25519",
+    "id_ecdsa",
+    # Cloud credentials (path-based, also bare name for stripped-path scenarios)
+    ".aws/credentials",
+    ".gcp/credentials",
+    "credentials",
+]
+
+# Template/example files that match .env.* but are not sensitive.
+SENSITIVE_EXEMPTIONS: set[str] = {
+    ".env.example",
+    ".env.sample",
+    ".env.template",
+}
+
+
+def is_sensitive_file(path: str) -> bool:
+    """Check if a file path matches any sensitive file pattern."""
+    name = PurePath(path).name
+    if name in SENSITIVE_EXEMPTIONS:
+        return False
+    for pattern in SENSITIVE_PATTERNS:
+        if "/" in pattern:
+            if path.endswith(pattern) or ("/" + pattern) in path:
+                return True
+        else:
+            if fnmatch.fnmatch(name, pattern):
+                return True
+    return False
+
+
+def sensitive_file_warning(paths: list[str]) -> str:
+    """Generate a warning message for sensitive files that were skipped."""
+    names = sorted({PurePath(p).name for p in paths})
+    file_list = ", ".join(names[:5])
+    if len(names) > 5:
+        file_list += f", ... ({len(names)} files total)"
+    return (
+        f"Skipped {len(paths)} sensitive file(s) ({file_list}) "
+        f"to protect secrets. These files may contain credentials or private keys."
+    )

pythinker_code/utils/server.py

@@ -0,0 +1,121 @@
+"""Shared utilities for pythinker vis and pythinker web server startup."""
+
+from __future__ import annotations
+
+import importlib
+import socket
+import textwrap
+
+
+def get_address_family(host: str) -> socket.AddressFamily:
+    """Return AF_INET6 for IPv6 addresses, AF_INET for IPv4 and hostnames."""
+    return socket.AF_INET6 if ":" in host else socket.AF_INET
+
+
+def format_url(host: str, port: int) -> str:
+    """Build ``http://host:port``, bracketing IPv6 literals per RFC 2732."""
+    if ":" in host:
+        return f"http://[{host}]:{port}"
+    return f"http://{host}:{port}"
+
+
+def is_local_host(host: str) -> bool:
+    """Check whether *host* resolves to a loopback address."""
+    return host in {"127.0.0.1", "localhost", "::1"}
+
+
+def find_available_port(host: str, start_port: int, max_attempts: int = 10) -> int:
+    """Find an available port starting from *start_port*.
+
+    Raises ``RuntimeError`` if no port is available within the range.
+    """
+    if max_attempts <= 0:
+        raise ValueError("max_attempts must be positive")
+    if start_port < 1 or start_port > 65535:
+        raise ValueError("start_port must be between 1 and 65535")
+
+    family = get_address_family(host)
+    for offset in range(max_attempts):
+        port = start_port + offset
+        with socket.socket(family, socket.SOCK_STREAM) as s:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            try:
+                s.bind((host, port))
+                return port
+            except OSError:
+                continue
+    raise RuntimeError(
+        f"Cannot find available port in range {start_port}-{start_port + max_attempts - 1}"
+    )
+
+
+def get_network_addresses() -> list[str]:
+    """Get non-loopback IPv4 addresses for this machine."""
+    addresses: list[str] = []
+
+    try:
+        hostname = socket.gethostname()
+        for info in socket.getaddrinfo(hostname, None, socket.AF_INET):
+            ip = info[4][0]
+            if isinstance(ip, str) and not ip.startswith("127.") and ip not in addresses:
+                addresses.append(ip)
+    except OSError:
+        pass
+
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.connect(("8.8.8.8", 80))
+            ip = s.getsockname()[0]
+        if ip and not ip.startswith("127.") and ip not in addresses:
+            addresses.append(ip)
+    except OSError:
+        pass
+
+    try:
+        netifaces = importlib.import_module("netifaces")
+        for interface in netifaces.interfaces():
+            addrs = netifaces.ifaddresses(interface)
+            if netifaces.AF_INET in addrs:
+                for addr_info in addrs[netifaces.AF_INET]:
+                    addr = addr_info.get("addr")
+                    if addr and not addr.startswith("127.") and addr not in addresses:
+                        addresses.append(addr)
+    except (ImportError, Exception):
+        pass
+
+    return addresses
+
+
+def print_banner(lines: list[str]) -> None:
+    """Print a boxed banner with tag conventions (<center>, <nowrap>, <hr>)."""
+    processed: list[str] = []
+    for line in lines:
+        if line == "<hr>":
+            processed.append(line)
+        elif not line:
+            processed.append("")
+        elif line.startswith("<center>") or line.startswith("<nowrap>"):
+            processed.append(line)
+        else:
+            processed.extend(textwrap.wrap(line, width=78))
+
+    def strip_tags(s: str) -> str:
+        return s.removeprefix("<center>").removeprefix("<nowrap>")
+
+    content_lines = [strip_tags(line) for line in processed if line != "<hr>"]
+    width = max(60, *(len(line) for line in content_lines))
+    top = "+" + "=" * (width + 2) + "+"
+
+    print(top)
+    for line in processed:
+        if line == "<hr>":
+            print("|" + "-" * (width + 2) + "|")
+        elif line.startswith("<center>"):
+            content = line.removeprefix("<center>")
+            print(f"| {content.center(width)} |")
+        elif line.startswith("<nowrap>"):
+            content = line.removeprefix("<nowrap>")
+            print(f"| {content.ljust(width)} |")
+        else:
+            print(f"| {line.ljust(width)} |")
+    print(top)

pythinker_code/utils/signals.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import signal
+from collections.abc import Callable
+
+
+def install_sigint_handler(
+    loop: asyncio.AbstractEventLoop, handler: Callable[[], None]
+) -> Callable[[], None]:
+    """
+    Install a SIGINT handler that works on Unix and Windows.
+
+    On Unix event loops, prefer `loop.add_signal_handler`.
+    On Windows (or other platforms) where it is not implemented, fall back to
+    `signal.signal`. The fallback cannot be removed from the loop, but we
+    restore the previous handler on uninstall.
+
+    Returns:
+        A function that removes the installed handler. It is guaranteed that
+        no exceptions are raised when calling the returned function.
+    """
+
+    try:
+        loop.add_signal_handler(signal.SIGINT, handler)
+
+        def remove() -> None:
+            with contextlib.suppress(RuntimeError):
+                loop.remove_signal_handler(signal.SIGINT)
+
+        return remove
+    except RuntimeError:
+        # Windows ProactorEventLoop and some environments do not support
+        # add_signal_handler. Use synchronous signal handling as a fallback.
+        previous = signal.getsignal(signal.SIGINT)
+        signal.signal(signal.SIGINT, lambda signum, frame: handler())
+
+        def remove() -> None:
+            with contextlib.suppress(RuntimeError):
+                signal.signal(signal.SIGINT, previous)
+
+        return remove

pythinker_code/utils/slashcmd.py

@@ -0,0 +1,124 @@
+import re
+from collections.abc import Awaitable, Callable, Sequence
+from dataclasses import dataclass
+from typing import overload
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SlashCommand[F: Callable[..., None | Awaitable[None]]]:
+    name: str
+    description: str
+    func: F
+    aliases: list[str]
+
+    def slash_name(self):
+        """/name (aliases)"""
+        if self.aliases:
+            return f"/{self.name} ({', '.join(self.aliases)})"
+        return f"/{self.name}"
+
+
+class SlashCommandRegistry[F: Callable[..., None | Awaitable[None]]]:
+    """Registry for slash commands."""
+
+    def __init__(self) -> None:
+        self._commands: dict[str, SlashCommand[F]] = {}
+        """Primary name -> SlashCommand"""
+        self._command_aliases: dict[str, SlashCommand[F]] = {}
+        """Primary name or alias -> SlashCommand"""
+
+    @overload
+    def command(self, func: F, /) -> F: ...
+
+    @overload
+    def command(
+        self,
+        *,
+        name: str | None = None,
+        aliases: Sequence[str] | None = None,
+    ) -> Callable[[F], F]: ...
+
+    def command(
+        self,
+        func: F | None = None,
+        *,
+        name: str | None = None,
+        aliases: Sequence[str] | None = None,
+    ) -> F | Callable[[F], F]:
+        """
+        Decorator to register a slash command with optional custom name and aliases.
+
+        Usage examples:
+          @registry.command
+          def help(app: App, args: str): ...
+
+          @registry.command(name="run")
+          def start(app: App, args: str): ...
+
+          @registry.command(aliases=["h", "?", "assist"])
+          def help(app: App, args: str): ...
+        """
+
+        def _register(f: F) -> F:
+            primary = name or f.__name__
+            alias_list = list(aliases) if aliases else []
+
+            # Create the primary command with aliases
+            cmd = SlashCommand[F](
+                name=primary,
+                description=(f.__doc__ or "").strip(),
+                func=f,
+                aliases=alias_list,
+            )
+
+            # Register primary command
+            self._commands[primary] = cmd
+            self._command_aliases[primary] = cmd
+
+            # Register aliases pointing to the same command
+            for alias in alias_list:
+                self._command_aliases[alias] = cmd
+
+            return f
+
+        if func is not None:
+            return _register(func)
+        return _register
+
+    def find_command(self, name: str) -> SlashCommand[F] | None:
+        return self._command_aliases.get(name)
+
+    def list_commands(self) -> list[SlashCommand[F]]:
+        """Get all unique primary slash commands (without duplicating aliases)."""
+        return list(self._commands.values())
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SlashCommandCall:
+    name: str
+    args: str
+    raw_input: str
+
+
+def parse_slash_command_call(user_input: str) -> SlashCommandCall | None:
+    """
+    Parse a slash command call from user input.
+
+    Returns:
+        SlashCommandCall if a slash command is found, else None. The `args` field contains
+        the raw argument string after the command name.
+    """
+    user_input = user_input.strip()
+    if not user_input or not user_input.startswith("/"):
+        return None
+
+    name_match = re.match(r"^\/([a-zA-Z0-9_-]+(?::[a-zA-Z0-9_-]+)*)", user_input)
+
+    if not name_match:
+        return None
+
+    command_name = name_match.group(1)
+    if len(user_input) > name_match.end() and not user_input[name_match.end()].isspace():
+        return None
+    raw_args = user_input[name_match.end() :].lstrip()
+    return SlashCommandCall(name=command_name, args=raw_args, raw_input=user_input)

pythinker_code/utils/string.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import random
+import re
+import string
+
+_NEWLINE_RE = re.compile(r"[\r\n]+")
+
+
+def shorten(text: str, *, width: int, placeholder: str = "…") -> str:
+    """Shorten text to at most *width* characters.
+
+    Normalises whitespace, then truncates — preferring a word boundary
+    when one exists near the cut point, but falling back to a hard cut
+    so that CJK text without spaces won't collapse to just the placeholder.
+    """
+    text = " ".join(text.split())
+    if len(text) <= width:
+        return text
+    cut = width - len(placeholder)
+    if cut <= 0:
+        return text[:width]
+    space = text.rfind(" ", 0, cut + 1)
+    if space > 0:
+        cut = space
+    return text[:cut].rstrip() + placeholder
+
+
+def shorten_middle(text: str, width: int, remove_newline: bool = True) -> str:
+    """Shorten the text by inserting ellipsis in the middle."""
+    if len(text) <= width:
+        return text
+    if remove_newline:
+        text = _NEWLINE_RE.sub(" ", text)
+    return text[: width // 2] + "..." + text[-width // 2 :]
+
+
+def random_string(length: int = 8) -> str:
+    """Generate a random string of fixed length."""
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for _ in range(length))

pythinker_code/utils/subprocess_env.py

@@ -0,0 +1,73 @@
+"""Utilities for subprocess environment handling.
+
+This module provides utilities to handle environment variables when spawning
+subprocesses from a PyInstaller-frozen application. The main issue is that
+PyInstaller's bootloader modifies LD_LIBRARY_PATH to prioritize bundled libraries,
+which can cause conflicts when spawning external programs that expect system libraries.
+
+See: https://pyinstaller.org/en/stable/common-issues-and-pitfalls.html
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+# Environment variables that PyInstaller may modify on Linux
+_PYINSTALLER_LD_VARS = [
+    "LD_LIBRARY_PATH",
+    "LD_PRELOAD",
+]
+
+
+def get_clean_env(base_env: dict[str, str] | None = None) -> dict[str, str]:
+    """
+    Get a clean environment suitable for spawning subprocesses.
+
+    In a PyInstaller-frozen application on Linux, this function restores
+    the original library path environment variables, preventing subprocesses
+    from loading incompatible bundled libraries.
+
+    Args:
+        base_env: Base environment to start from. If None, uses os.environ.
+
+    Returns:
+        A dictionary of environment variables safe for subprocess use.
+    """
+    env = dict(base_env if base_env is not None else os.environ)
+
+    # Only process in PyInstaller frozen environment on Linux
+    if not getattr(sys, "frozen", False) or sys.platform != "linux":
+        return env
+
+    for var in _PYINSTALLER_LD_VARS:
+        orig_key = f"{var}_ORIG"
+        if orig_key in env:
+            # Restore the original value that was saved by PyInstaller bootloader
+            env[var] = env[orig_key]
+        elif var in env:
+            # Variable was not set before PyInstaller modified it, so remove it
+            del env[var]
+
+    return env
+
+
+def get_noninteractive_env(base_env: dict[str, str] | None = None) -> dict[str, str]:
+    """
+    Get an environment for subprocesses that must not block on interactive prompts.
+
+    Builds on :func:`get_clean_env` and additionally configures git to fail
+    fast instead of waiting for user input that will never arrive.
+
+    Args:
+        base_env: Base environment to start from. If None, uses os.environ.
+
+    Returns:
+        A dictionary of environment variables safe for non-interactive subprocess use.
+    """
+    env = get_clean_env(base_env)
+
+    # GIT_TERMINAL_PROMPT=0 makes git fail instead of prompting for credentials.
+    env.setdefault("GIT_TERMINAL_PROMPT", "0")
+
+    return env