stcode 0.0.1a0__tar.gz → 0.0.1a2__tar.gz

{stcode-0.0.1a0 → stcode-0.0.1a2}/CLAUDE.md

@@ -187,7 +187,7 @@ Seven. Each exists because violating it produced a specific, known failure.
 | Schemas | `pydantic` v2 | Signature → JSON Schema for free |
 | CLI | `typer` | |
 | Config | `tomllib` (read) + `tomli-w` (write) | Stdlib is read-only; the UI writes config back |
-| Search | `ripgrep` (pip wheel), `fd` (optional) | The wheel drops `rg` next to the interpreter, so `grep` works on a fresh checkout |
+| Search | `ripgrep-bin` (pip wheel), `fd` (optional) | The wheel installs `rg` without a Rust build on common platforms |
 | Tool schemas | `docstring-parser` | Signature + `Args:` → JSON Schema, described once |
 | MCP | `mcp` (official SDK) | We adapt it; we never reimplement the protocol |
 | Tracing | Direct HTTP JSON with `httpx` | Langfuse and Phoenix; no tracing SDK |

{stcode-0.0.1a0 → stcode-0.0.1a2}/Dockerfile

@@ -21,7 +21,7 @@
 FROM python:3.12-slim
 
 # git is not optional here: every role clones from /team/repo.git before writing code.
-# ripgrep arrives as a wheel with the package, so it is not installed twice.
+# ripgrep-bin supplies rg with the package, so it is not installed twice.
 RUN apt-get update && apt-get install -y --no-install-recommends \
         git ca-certificates \
     && rm -rf /var/lib/apt/lists/*

{stcode-0.0.1a0 → stcode-0.0.1a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stcode
-Version: 0.0.1a0
+Version: 0.0.1a2
 Summary: A coding agent that lives in a daemon, and a UI that is a client of it.
 Project-URL: Homepage, https://ming-doan.github.io/stcode/
 Project-URL: Documentation, https://ming-doan.github.io/stcode/docs/
@@ -30,7 +30,7 @@ Requires-Dist: mcp>=2.1.1
 Requires-Dist: openai>=3.0.0
 Requires-Dist: pydantic>=2.13.4
 Requires-Dist: python-dotenv>=1.2.3
-Requires-Dist: ripgrep>=15.1.0
+Requires-Dist: ripgrep-bin>=15.2.0
 Requires-Dist: textual>=8.2.8
 Requires-Dist: tomli-w>=1.2.0
 Requires-Dist: tomli>=2.0.1; python_version < '3.11'

{stcode-0.0.1a0 → stcode-0.0.1a2}/docs/architecture/configuration.md

@@ -127,14 +127,14 @@ project) and `keep`, the number of session files `prune` leaves behind.
 
 | Key | Default | |
 | --- | --- | --- |
-| `transport` | `"unix"` | `unix` on your machine, `tcp` in a container |
+| `transport` | `"unix"` on Unix, `"tcp"` on Windows | `tcp` also works in a container |
 | `socket` | `~/.stcode/daemon.sock` | `unix` only |
 | `host` / `port` | `127.0.0.1` / `7717` | `tcp` only |
 | `max_clients` | *unset* | concurrent connections. **Unset = 1 in a container, unlimited on the host**; `0` is unlimited everywhere |
 
-Read by the daemon only. The UI connects to `~/.stcode/daemon.sock` unless given
-`--socket` or `--transport tcp --host --port`, and starts the daemon on that same
-address. → [daemon.md](daemon.md#one-client-in-a-container)
+Read by the daemon only. The UI connects to `~/.stcode/daemon.sock` on Unix or
+`127.0.0.1:7717` over TCP on Windows unless given address flags, and starts the daemon
+on that same address. → [daemon.md](daemon.md#one-client-in-a-container)
 
 ### `[mcp]`
 

{stcode-0.0.1a0 → stcode-0.0.1a2}/docs/architecture/daemon.md

@@ -41,9 +41,10 @@ stcode --daemonless   # the UI alone, attached to a daemon elsewhere
 ```
 
 No implementation switches between them. `--headless` replaces the `stcode` process
-with `stcode-daemon`. Plain `stcode` connects to `~/.stcode/daemon.sock` (or the address
-its flags name); if nothing answers, `cli/services/launcher.py` starts `stcode-daemon` on that
-address as a subprocess, logging to `~/.stcode/daemon.log`, and stops it again when the
+with `stcode-daemon`. Plain `stcode` connects to `~/.stcode/daemon.sock` on Unix or
+`127.0.0.1:7717` over TCP on Windows (or the address its flags name); if nothing answers,
+`cli/services/launcher.py` starts `stcode-daemon` on that address as a subprocess,
+logging to `daemon.log` in the stcode home directory, and stops it again when the
 UI exits. A daemon it *found* is left running — quitting is a detach. `stcode --restart`
 sends `shutdown` to whatever is listening first, for a daemon that is wedged or running
 old code.
@@ -260,17 +261,24 @@ the container is the mitigation.
 
 ```toml
 [daemon]
-transport = "unix"            # "tcp" inside a container
+# transport = "unix"          # default on Unix; "tcp" on Windows
 socket    = "~/.stcode/daemon.sock"
 host      = "127.0.0.1"
 port      = 7717
 ```
 
-`unix` for solo — no port to collide with, and filesystem permissions are the access
-control (the socket is chmod 0600; anyone who can open it can drive an agent with your
+`unix` for solo on Unix — no port to collide with, and filesystem permissions are the
+access control (the socket is chmod 0600; anyone who can open it can drive an agent with your
 privileges). `tcp` for a container, which has no host filesystem to put a socket on. Same
 JSONL framing either way, so a WebSocket adapter later is an adapter, not a protocol.
 
+Both the client and daemon default to loopback TCP when asyncio's Unix socket APIs
+are unavailable, as on Windows. Explicitly requesting `unix` on such a platform
+reports an unsupported transport with a hint to use `--transport tcp`.
+On Windows, set provider keys in the daemon's config file or environment: TCP still
+refuses API key updates and protocol shutdown, including `--restart` of a running
+daemon. The launcher can stop a daemon it started when the UI exits.
+
 **Transport is configuration, not architecture.** The one thing that reads it is
 `Daemon.local_only`, which decides what only this machine's user may do — send a key,
 stop the daemon. Anything else that needs to know is in the wrong layer.

{stcode-0.0.1a0 → stcode-0.0.1a2}/docs/architecture/harness.md

@@ -118,7 +118,7 @@ tool. A call may narrow what it claims, never widen it.
 | `bash` | `bash(command, timeout=120, background=False, cwd="", description="")` | **each call is a fresh process**, and the docstring says so |
 | `bash_output` | `bash_output(shell_id, kill=False)` | drains a background shell, new output only |
 | `glob` | `glob(pattern, path=".")` | `fd`, falling back to `rg --files`, then `pathlib` |
-| `grep` | `grep(pattern, path=".", ...)` | ripgrep. Do not hand-roll |
+| `grep` | `grep(pattern, path=".", ...)` | ripgrep, installed through `ripgrep-bin` |
 | `ls` | `ls(path)` | `.gitignore`-aware |
 | `todo_write` | `todo_write(items)` | not a real tool — a device to keep the plan in context. Keep it |
 | `ask_user_question` | `ask_user_question(question, options=None, header="", multi_select=False)` | fails clearly with no user attached, rather than hanging |

{stcode-0.0.1a0 → stcode-0.0.1a2}/docs/getting-started/installation.md

@@ -26,8 +26,9 @@ pip install stcode
 stcode --version
 ```
 
-The package includes the search dependency; you do not need to install ripgrep
-separately.
+Search is included through `ripgrep-bin`, which supplies prebuilt binaries for
+common Linux and macOS systems. You do not need a separate ripgrep installation
+or a Rust compiler on those platforms.
 
 ## Run from source
 

{stcode-0.0.1a0 → stcode-0.0.1a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stcode"
-version = "0.0.1a0"
+version = "0.0.1a2"
 description = "A coding agent that lives in a daemon, and a UI that is a client of it."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -30,7 +30,7 @@ dependencies = [
     "openai>=3.0.0",
     "pydantic>=2.13.4",
     "python-dotenv>=1.2.3",
-    "ripgrep>=15.1.0",
+    "ripgrep-bin>=15.2.0",
     "textual>=8.2.8",
     "tomli>=2.0.1; python_version < '3.11'",
     "tomli-w>=1.2.0",

{stcode-0.0.1a0 → stcode-0.0.1a2}/stcode/cli/main.py

@@ -178,7 +178,9 @@ def main(
 def _address(
     transport: str | None, socket: str | None, host: str | None, port: int | None
 ) -> Address:
-    address = Address(transport=transport or "unix")
+    address = Address()
+    if transport:
+        address.transport = transport
     if socket:
         address.socket = Path(socket).expanduser()
     address.host = host or address.host

{stcode-0.0.1a0 → stcode-0.0.1a2}/stcode/cli/services/client.py

@@ -44,7 +44,9 @@ rather than hung on."""
 class Address:
     """Where a daemon listens."""
 
-    transport: str = "unix"
+    transport: str = field(
+        default_factory=lambda: "unix" if hasattr(asyncio, "open_unix_connection") else "tcp"
+    )
     socket: Path = field(default_factory=lambda: stcode_home() / "daemon.sock")
     host: str = "127.0.0.1"
     port: int = 7717
@@ -91,6 +93,10 @@ class DaemonClient:
         """Open the transport. `OSError` when nothing is listening — the caller's cue to
         start a daemon or ask for another address, not an error to hide."""
         if address.transport == "unix":
+            if not hasattr(asyncio, "open_unix_connection"):
+                raise OSError(
+                    "Unix sockets are unavailable on this platform; use --transport tcp."
+                )
             reader, writer = await asyncio.open_unix_connection(
                 str(address.socket.expanduser()), limit=STREAM_LIMIT
             )

{stcode-0.0.1a0 → stcode-0.0.1a2}/stcode/core/configs.py

@@ -17,6 +17,7 @@ A leaf: imports nothing from `stcode`, so anything in `core/` may import it.
 
 from __future__ import annotations
 
+import asyncio
 import os
 import re
 from pathlib import Path
@@ -103,13 +104,16 @@ class DaemonConfig(BaseModel):
     """Where the daemon listens.
     Args:
         transport: `unix` — socket via `socket` path, `tcp` — socket via `host` and `port`.
+            Defaults to `tcp` when asyncio has no Unix socket support (Windows).
         socket: Path to the Unix socket file. Ignored if `transport` is `tcp`.
         host: Hostname to bind to. Ignored if `transport` is `unix`.
         port: Port to bind to. Ignored if `transport` is `unix`.
         max_clients: How many clients may be connected at once. 0 = unlimited. Unset =
             1 in a container, unlimited on the host.
     """
-    transport: Literal["unix", "tcp"] = "unix"
+    transport: Literal["unix", "tcp"] = Field(
+        default_factory=lambda: "unix" if hasattr(asyncio, "start_unix_server") else "tcp"
+    )
     socket: Path = Field(default_factory=lambda: home_dir() / "daemon.sock")
     host: str = "127.0.0.1"
     port: int = 7717

{stcode-0.0.1a0 → stcode-0.0.1a2}/stcode/core/daemon/server.py

@@ -155,6 +155,10 @@ class Daemon:
 
         settings = self.config.daemon
         if settings.transport == "unix":
+            if not hasattr(asyncio, "start_unix_server"):
+                raise OSError(
+                    "Unix sockets are unavailable on this platform; use --transport tcp."
+                )
             path = socket_path(settings.socket)
             path.parent.mkdir(parents=True, exist_ok=True)
             _clear_stale_socket(path)

{stcode-0.0.1a0 → stcode-0.0.1a2}/stcode/core/harness/tools/search.py

@@ -6,9 +6,9 @@ semantics, binary detection, encoding recovery and PCRE2 are each a project's wo
 edge cases, and a Python reimplementation gets them wrong in ways that surface as an
 agent confidently reporting a symbol does not exist.
 
-`ripgrep` is a declared dependency (a wheel drops `rg` next to the interpreter). `fd`
-has no wheel, so `glob` degrades to `rg --files`, then to `pathlib`. A missing binary
-should cost speed, not the tool.
+`ripgrep-bin` supplies `rg` in the environment's scripts directory, with prebuilt
+wheels for common platforms. `fd` is optional, so `glob` degrades to `rg --files`,
+then to `pathlib`.
 """
 
 from __future__ import annotations
@@ -71,7 +71,7 @@ async def run_capture(
 def find_binary(name: str) -> str | None:
     """Locate a helper binary on PATH, or next to the interpreter.
 
-    The second half is what makes the bundled ripgrep work: a wheel-installed binary
+    The second half is what makes ripgrep-bin work: a wheel-installed binary
     lands beside `python` in the virtualenv, which is on PATH when it is activated and
     not when something invokes `.venv/bin/python` directly.
     """
@@ -211,8 +211,8 @@ async def grep(
         raise ToolError(f"{target} does not exist.")
     if not _have("rg"):
         raise ToolError(
-            "ripgrep (`rg`) could not be found, though it is a declared dependency of "
-            "stcode. Reinstall the environment (`uv sync`), or put `rg` on PATH."
+            "ripgrep (`rg`) could not be found. Reinstall stcode's ripgrep-bin "
+            "dependency (`pip install --force-reinstall ripgrep-bin`), or put `rg` on PATH."
         )
 
     argv = [find_binary("rg") or "rg", "--no-messages"]

{stcode-0.0.1a0 → stcode-0.0.1a2}/stcode.example.toml

@@ -63,11 +63,11 @@ difficulty = "high"
 # dir = "./.stcode/sessions"
 # keep = 100
 
-# Where the daemon listens. `unix` on your own machine, `tcp` inside a container.
-# The UI does not read this: it connects to ~/.stcode/daemon.sock unless told otherwise
-# with --socket / --transport tcp --host --port, and starts the daemon on that address.
+# Where the daemon listens. Default: `unix` on Unix, loopback `tcp` on Windows.
+# Use `tcp` inside a container. The UI does not read this: it uses the same platform
+# default unless given --transport / --socket / --host / --port flags.
 [daemon]
-transport = "unix"
+# transport = "unix"     # use "tcp" on Windows or inside a container
 # socket = "~/.stcode/daemon.sock"
 # host = "0.0.0.0"       # when transport = "tcp"
 # port = 7717

{stcode-0.0.1a0 → stcode-0.0.1a2}/tests/core/harness_test.py

@@ -357,6 +357,28 @@ def test_grep_reports_no_matches_without_erroring(rt: Runtime[HarnessContext], r
     assert not result.is_error and "No matches" in result.content
 
 
+def test_bundled_search_works_without_a_system_binary_or_activated_environment(
+    rt: Runtime[HarnessContext], run: Any, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    root = rt.context.cwd
+    subprocess.run(["git", "init", "-q", str(root)], check=True)
+    (root / ".gitignore").write_text("ignored.py\n", encoding="utf-8")
+    (root / "café.py").write_text("message = 'héllo'\n", encoding="utf-8")
+    (root / "ignored.py").write_text("message = 'héllo'\n", encoding="utf-8")
+    (root / "other.txt").write_text("héllo\n", encoding="utf-8")
+    # Invoking a virtualenv's Python directly does not activate its scripts directory.
+    monkeypatch.setenv("PATH", "")
+
+    hits = run(grep.invoke({"pattern": "héllo", "type": "py", "output_mode": "content"}, rt))
+    assert not hits.is_error
+    assert "café.py:1:message = 'héllo'" in hits.content
+    assert "ignored.py" not in hits.content and "other.txt" not in hits.content
+
+    files = run(glob.invoke({"pattern": "**/*.py"}, rt))
+    assert not files.is_error
+    assert "café.py" in files.content and "other.txt" not in files.content
+
+
 def test_ls_marks_directories_and_skips_noise(rt: Runtime[HarnessContext], run: Any) -> None:
     (rt.context.cwd / "src").mkdir()
     (rt.context.cwd / "__pycache__").mkdir()

stcode-0.0.1a2/tests/integration/transport_test.py

@@ -0,0 +1,96 @@
+"""Platform transport defaults must agree without requiring Unix-only asyncio APIs."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import pytest
+from driving import asynctest
+
+from stcode.cli.main import _address
+from stcode.cli.services.client import Address, DaemonClient
+from stcode.core.configs import Config, load_config
+from stcode.core.daemon import Daemon
+
+
+@pytest.fixture
+def without_unix_sockets(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Match Windows' asyncio surface while still using real TCP sockets."""
+    monkeypatch.delattr(asyncio, "open_unix_connection", raising=False)
+    monkeypatch.delattr(asyncio, "start_unix_server", raising=False)
+
+
+@pytest.mark.skipif(
+    not hasattr(asyncio, "open_unix_connection")
+    or not hasattr(asyncio, "start_unix_server"),
+    reason="Unix socket APIs are unavailable",
+)
+def test_unix_remains_the_default_where_supported() -> None:
+    assert Address().transport == "unix"
+    assert _address(None, None, None, None).transport == "unix"
+    assert Config().daemon.transport == "unix"
+    assert _address("tcp", None, "127.0.0.1", 9000).daemon_args() == [
+        "--transport", "tcp", "--host", "127.0.0.1", "--port", "9000",
+    ]
+
+
+@asynctest
+async def test_defaults_connect_over_tcp_without_unix_apis(
+    tmp_path: Path, without_unix_sockets: None,
+) -> None:
+    address = _address(None, None, None, None)
+    assert address.transport == Address().transport == "tcp"
+    assert str(address) == "127.0.0.1:7717"
+    assert address.daemon_args() == [
+        "--transport", "tcp", "--host", "127.0.0.1", "--port", "7717",
+    ]
+
+    path = tmp_path / "config.toml"
+    config = load_config(
+        path,
+        create_if_missing=True,
+        overrides={"session.dir": str(tmp_path / "sessions"), "daemon.port": 0},
+    )
+    assert config.daemon.transport == "tcp"
+    assert load_config(path).daemon.transport == "tcp"
+    assert config.daemon.host == address.host
+
+    async with Daemon(config) as daemon:
+        assert daemon._server is not None
+        address.port = daemon._server.sockets[0].getsockname()[1]
+        async with await DaemonClient.connect(address) as client:
+            frame = await client.get_config()
+            assert frame["path"] == str(path)
+            assert frame["keys_editable"] is False
+            assert await client.sessions() == []
+
+
+@asynctest
+async def test_explicit_unix_client_reports_how_to_use_tcp(
+    tmp_path: Path, without_unix_sockets: None,
+) -> None:
+    address = _address("unix", str(tmp_path / "d.sock"), None, None)
+    assert address.transport == "unix"
+    with pytest.raises(OSError, match="Unix sockets.*--transport tcp"):
+        await DaemonClient.connect(address)
+
+
+@asynctest
+async def test_explicit_unix_daemon_reports_how_to_use_tcp(
+    tmp_path: Path, without_unix_sockets: None,
+) -> None:
+    config = load_config(
+        tmp_path / "config.toml",
+        create_if_missing=True,
+        overrides={
+            "daemon.transport": "unix",
+            "daemon.socket": str(tmp_path / "d.sock"),
+            "session.dir": str(tmp_path / "sessions"),
+        },
+    )
+    assert config.daemon.transport == "unix"
+    with pytest.raises(OSError, match="Unix sockets.*--transport tcp"):
+        async with Daemon(config):
+            pass
+    assert not config.daemon.socket.exists()

{stcode-0.0.1a0 → stcode-0.0.1a2}/uv.lock

@@ -2952,13 +2952,18 @@ wheels = [
 ]
 
 [[package]]
-name = "ripgrep"
-version = "15.1.0"
+name = "ripgrep-bin"
+version = "15.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1e/18/0740869cfcee3b9671d601aec90541cc68e342794cecf02c6eec7ee12f19/ripgrep-15.1.0.tar.gz", hash = "sha256:3b4793859cd25c57ffd894b59ba9155636616b4084a1c12d0b9e819c16931ebf", size = 488918, upload-time = "2026-05-24T04:02:30.224Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/be/305c3f0b1a2a69e74635d974c687db245c4f27a978ba46740f8699daec08/ripgrep_bin-15.2.0.tar.gz", hash = "sha256:692e26e280c68cbbbb4efe7d1e2e37ffa74a5cef50c8910eac053da1b309d414", size = 488682, upload-time = "2026-07-16T00:50:36.157Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/42/994bb17dc45399f60bc850c9ea295b9638eb7abee9ec26cc386a2ebc264d/ripgrep-15.1.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3f99a068cea48d10ffc6b3c43bef37b684e1ba449d4ae57b0f96c4521f8d923f", size = 2072593, upload-time = "2026-05-24T04:02:26.66Z" },
-    { url = "https://files.pythonhosted.org/packages/29/5c/951baee5033a25e9b79df51b378276fd0b3a88c7aba9665d50178e9738c1/ripgrep-15.1.0-py3-none-manylinux_2_39_x86_64.whl", hash = "sha256:9b9bbd02a7f2c3e88882f9a9df416da8e272957071ba8ab59a7a7f06813643cf", size = 7817112, upload-time = "2026-05-24T04:02:28.625Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/83/7c7a7a2ec8f9d1e87a62300805c42189ec9256610a7635e7860a9ff1909e/ripgrep_bin-15.2.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:cdb262a09ca747526ec9fb3a9a4f5400cfe0923bcce4e436ef3d1930365b45bc", size = 2130077, upload-time = "2026-07-16T00:50:22.634Z" },
+    { url = "https://files.pythonhosted.org/packages/00/2e/21879548e11236f7fabe4daa08e7c8397e7ccd3543979806834497032626/ripgrep_bin-15.2.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c3f669ef5bba3a62d826bfecc81b228c849bc2f7206befe2bc2eed89b3baffaf", size = 2092467, upload-time = "2026-07-16T00:50:24.792Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e1/6f849937cedc3c5a7ab8e1c2472a8ca5f9cb54d6aa2f9baeb1b5398bdb48/ripgrep_bin-15.2.0-py3-none-manylinux_2_28_aarch64.musllinux_1_2_aarch64.whl", hash = "sha256:969e2639ffe692f33fc94e9a197921c16f85f3e16247e20e1dde554cc6f264ba", size = 2071927, upload-time = "2026-07-16T00:50:26.512Z" },
+    { url = "https://files.pythonhosted.org/packages/39/41/71cf0d754d5422a2700fd8cd656d653655b1c6f50dc3281f182ee70eaab3/ripgrep_bin-15.2.0-py3-none-manylinux_2_28_x86_64.musllinux_1_2_x86_64.whl", hash = "sha256:d9a21aed0ce8b7e40eea1737b37bc8f10b4794afa755269d28512b1007c3ea7f", size = 2308745, upload-time = "2026-07-16T00:50:28.633Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/39/3f0d53c7febee5ae8d702a17f7eb67ff09c61e0810c219b4b369e064003f/ripgrep_bin-15.2.0-py3-none-manylinux_2_31_riscv64.musllinux_1_2_riscv64.whl", hash = "sha256:78c827b26b396b17a6a07cdbdd001513af6c5f884bc85d994ad0fc4218dca78a", size = 2323944, upload-time = "2026-07-16T00:50:30.575Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/eb/6e5a8f52c8568f018bc5e2f5f467ec99703023e3430690e507b586c40ada/ripgrep_bin-15.2.0-py3-none-win_amd64.whl", hash = "sha256:f56ddf23f1a53cb61c2b3a72d136f98e271c28e3cb06a4fa2ee06b6304f1a5c9", size = 2124440, upload-time = "2026-07-16T00:50:32.388Z" },
+    { url = "https://files.pythonhosted.org/packages/66/53/4c5e6463a6b3f5f2bba6a9afda2428003727cb8233383557cfe4f0bc8526/ripgrep_bin-15.2.0-py3-none-win_arm64.whl", hash = "sha256:0fed6501a518cb28641301361210d51b9351cbc867302f9f41978f8b64cb0eb1", size = 2014362, upload-time = "2026-07-16T00:50:34.449Z" },
 ]
 
 [[package]]
@@ -3284,7 +3289,7 @@ wheels = [
 
 [[package]]
 name = "stcode"
-version = "0.0.1a0"
+version = "0.0.1a2"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },
@@ -3296,7 +3301,7 @@ dependencies = [
     { name = "openai" },
     { name = "pydantic" },
     { name = "python-dotenv" },
-    { name = "ripgrep" },
+    { name = "ripgrep-bin" },
     { name = "textual" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
     { name = "tomli-w" },
@@ -3328,7 +3333,7 @@ requires-dist = [
     { name = "openai", specifier = ">=3.0.0" },
     { name = "pydantic", specifier = ">=2.13.4" },
     { name = "python-dotenv", specifier = ">=1.2.3" },
-    { name = "ripgrep", specifier = ">=15.1.0" },
+    { name = "ripgrep-bin", specifier = ">=15.2.0" },
     { name = "textual", specifier = ">=8.2.8" },
     { name = "tomli", marker = "python_full_version < '3.11'", specifier = ">=2.0.1" },
     { name = "tomli-w", specifier = ">=1.2.0" },