hx-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{hx_cli-0.1.2 → hx_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: HX - a terminal coding agent
 Project-URL: Homepage, https://github.com/aletisunil/hx
 Project-URL: Issues, https://github.com/aletisunil/hx/issues

hx_cli-0.1.4/install.sh

@@ -0,0 +1,136 @@
+#!/bin/sh
+# HX installer.
+#
+#   curl -fsSL https://raw.githubusercontent.com/aletisunil/hx/main/install.sh | sh
+#
+# Bootstraps `uv` if it is missing, then installs hx as an isolated uv tool with
+# a pinned Python. Idempotent: re-running upgrades in place.
+
+set -eu
+
+# The PyPI distribution is hx-cli; the command it installs is `hx`.
+HX_PACKAGE="${HX_PACKAGE:-hx-cli}"
+HX_PYTHON="${HX_PYTHON:-3.12}"
+HX_SUPPORT_EMAIL="iam@sunilaleti.dev"
+UV_INSTALLER="https://astral.sh/uv/install.sh"
+
+log()  { printf '\033[0;36m==>\033[0m %s\n' "$1"; }
+warn() { printf '\033[0;33mwarning:\033[0m %s\n' "$1" >&2; }
+die()  {
+    printf '\033[0;31merror:\033[0m %s\n' "$1" >&2
+    printf 'Need help? Contact \033[1;33m%s\033[0m\n' "$HX_SUPPORT_EMAIL" >&2
+    exit 1
+}
+
+have() { command -v "$1" >/dev/null 2>&1; }
+
+should_animate() {
+    [ -t 1 ] && [ -z "${HX_NO_ANIMATION:-}" ] && [ -z "${CI:-}" ]
+}
+
+render_logo() {
+    padding=$1
+    clear_prefix=
+    [ "${2:-}" = clear ] && clear_prefix='\033[2K\r'
+
+    printf '\033[0;36m'
+    printf '%b%s%s\n' "$clear_prefix" "$padding" ' _   _  __  __'
+    printf '%b%s%s\n' "$clear_prefix" "$padding" '| | | | \ \/ /'
+    printf '%b%s%s\n' "$clear_prefix" "$padding" '| |_| |  >  <'
+    printf '%b%s%s\n' "$clear_prefix" "$padding" "|  _  | / /\\ \\"
+    printf '%b%s%s\n' "$clear_prefix" "$padding" "|_| |_|/_/  \\_\\"
+    printf '\033[0m'
+}
+
+animate_logo() {
+    if ! should_animate; then
+        render_logo ''
+        return
+    fi
+
+    # Slide in, overshoot slightly, then settle into place.
+    render_logo '            ' clear
+    sleep 0.07
+    printf '\033[5A'
+    render_logo '        ' clear
+    sleep 0.07
+    printf '\033[5A'
+    render_logo '    ' clear
+    sleep 0.07
+    printf '\033[5A'
+    render_logo '' clear
+    sleep 0.07
+    printf '\033[5A'
+    render_logo '  ' clear
+    sleep 0.07
+    printf '\033[5A'
+    render_logo '' clear
+}
+
+stream_text() {
+    message=$1
+    printf '  '
+    if should_animate; then
+        # Word-by-word output keeps the effect portable across macOS and Linux.
+        # shellcheck disable=SC2086  # Intentional word splitting for animation.
+        for word in $message; do
+            printf '%s ' "$word"
+            sleep 0.03
+        done
+        printf '\n'
+    else
+        printf '%s\n' "$message"
+    fi
+}
+
+banner() {
+    animate_logo
+    printf '\n'
+    stream_text 'HX is a terminal coding agent that works inside your project.'
+    stream_text 'It reads and edits files, runs commands in a sandbox, and handles larger tasks with persistent sessions, skills, tools, and subagents.'
+    stream_text 'Connect to models through OpenRouter and see context, cost, and usage for every turn.'
+    printf '  Questions or issues? Contact \033[1;33m%s\033[0m\n\n' "$HX_SUPPORT_EMAIL"
+}
+
+ensure_uv() {
+    if have uv; then
+        log "uv found: $(uv --version)"
+        return
+    fi
+    log "Installing uv"
+    have curl || have wget || die "need curl or wget to bootstrap uv"
+    if have curl; then
+        curl -LsSf "$UV_INSTALLER" | sh
+    else
+        wget -qO- "$UV_INSTALLER" | sh
+    fi
+    # The uv installer drops binaries here but does not touch the current shell.
+    for candidate in "$HOME/.local/bin" "$HOME/.cargo/bin"; do
+        [ -x "$candidate/uv" ] && PATH="$candidate:$PATH"
+    done
+    export PATH
+    have uv || die "uv installed but not on PATH; open a new shell and re-run"
+}
+
+install_hx() {
+    log "Installing $HX_PACKAGE (Python $HX_PYTHON)"
+    uv tool install --python "$HX_PYTHON" --force "$HX_PACKAGE"
+}
+
+check_path() {
+    have hx && return
+    bindir="$(uv tool dir --bin 2>/dev/null || echo "$HOME/.local/bin")"
+    warn "hx is not on your PATH yet."
+    # shellcheck disable=SC2016  # $PATH is literal text for the user to copy.
+    printf '\n  Add this to your shell profile:\n\n    export PATH="%s:$PATH"\n\n' "$bindir"
+}
+
+main() {
+    banner
+    ensure_uv
+    install_hx
+    check_path
+    log "Done. Run 'hx' inside a project directory."
+}
+
+main "$@"

{hx_cli-0.1.2 → hx_cli-0.1.4}/src/hx/__init__.py

@@ -1,5 +1,5 @@
 """HX - a terminal coding agent."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 __all__ = ["__version__"]

{hx_cli-0.1.2 → hx_cli-0.1.4}/src/hx/tui/app.py

@@ -359,16 +359,20 @@ class HXApp(App[None]):
 
     async def _run_turn(self, text: str) -> None:
         prompt_input = self._prompt
-        prompt_input.set_enabled(False)
+        prompt_input.set_running(True)
         try:
             await self.loop.run(text)
         except asyncio.CancelledError:
             self._transcript.add_notice("interrupted", "warning")
         finally:
-            prompt_input.set_enabled(True)
+            prompt_input.set_running(False)
             self._working.stop()
 
         if self._queued:
+            # This coroutine is still the active Textual worker until it
+            # returns, so submit() would otherwise see a running turn and put
+            # the same prompt straight back on the queue.
+            self._turn_worker = None
             await self.submit(self._queued.pop(0))
 
     def _command_context(self) -> CommandContext:
@@ -498,18 +502,17 @@ class HXApp(App[None]):
         prompt: escape does that, and a key that sometimes discards a draft and
         sometimes kills a turn is a key nobody presses confidently.
 
-        While a turn *is* running there is no draft to discard and nothing
-        ambiguous left, so the key means what every terminal user expects it to
-        mean. Arming the exit there instead would let two presses of the
-        universal "stop" chord tear down the session mid-answer.
+        With an empty prompt during a running turn, the key means what every
+        terminal user expects it to mean. A draft still takes priority so it
+        can be cleared without interrupting the agent; escape always interrupts.
         """
-        if self._turn_worker is not None and not self._turn_worker.is_finished:
-            await self.action_interrupt()
-            return
         if self._prompt.text:
             self._prompt.clear()
             self._clear_armed = False
             return
+        if self._turn_worker is not None and not self._turn_worker.is_finished:
+            await self.action_interrupt()
+            return
         if self._clear_armed:
             self.exit()
             return

{hx_cli-0.1.2 → hx_cli-0.1.4}/src/hx/tui/widgets/input.py

@@ -21,6 +21,7 @@ from hx.tui.widgets.autocomplete import Autocomplete, Candidate, Completion
 MAX_HISTORY = 500
 
 PLACEHOLDER = "Ask HX…  (/ for commands)"
+RUNNING_PLACEHOLDER = "Ask HX…  (Enter to queue)"
 
 #: Actions that have to beat TextArea's own bindings. A focused widget wins in
 #: Textual, so ctrl+c would copy and ctrl+d would delete a character before the
@@ -249,7 +250,18 @@ class PromptInput(TextArea):
             completion.move(-1 if key == "up" else 1)
             self._sync_popup()
             return True
-        if self._matches(key, "tui.input.complete") or self._matches(key, "tui.input.submit"):
+        if self._matches(key, "tui.input.submit"):
+            # Once the prompt already contains the highlighted completion,
+            # Enter means submit. Treating it as another completion acceptance
+            # made exact slash commands such as /clear and /model require a
+            # surprising second Enter.
+            candidate = completion.current
+            if candidate is not None and self.text == completion.prefix + candidate.value:
+                self._submit()
+            else:
+                self.accept_completion()
+            return True
+        if self._matches(key, "tui.input.complete"):
             self.accept_completion()
             return True
         if self._matches(key, "app.interrupt"):
@@ -366,11 +378,13 @@ class PromptInput(TextArea):
             return
         popup.show(self.completion)
 
-    def set_enabled(self, enabled: bool) -> None:
-        """Disabled while a turn streams; queued input is submitted after."""
-        self.read_only = not enabled
-        interrupt = KEYMAP.text("app.interrupt")
-        self.set_placeholder(PLACEHOLDER if enabled else f"{interrupt} to interrupt…")
+    def set_running(self, running: bool) -> None:
+        """Reflect turn state without locking the user's draft.
+
+        Submissions made while a turn is running are queued by ``HXApp``.  The
+        prompt must stay editable so the user can prepare and submit them.
+        """
+        self.set_placeholder(RUNNING_PLACEHOLDER if running else PLACEHOLDER)
 
 
 class FileCompleter:

{hx_cli-0.1.2 → hx_cli-0.1.4}/tests/permissions/test_sandbox.py

@@ -18,7 +18,6 @@ from hx.permissions.sandbox import (
     Sandbox,
     SandboxBackend,
     SandboxPolicy,
-    build_bwrap_argv,
     build_seatbelt_profile,
     default_policy,
     detect_backend,
@@ -76,15 +75,6 @@ def test_deny_paths_are_resolved_before_emission(tmp_path: Path) -> None:
     assert str(real.resolve()) in profile
 
 
-def test_bwrap_argv_unshares_the_network_by_default(project: Path) -> None:
-    argv = build_bwrap_argv(default_policy(project), ["/bin/sh", "-c", "true"])
-    assert "--unshare-net" in argv
-    assert argv[:3] == ["bwrap", "--ro-bind", "/"]
-    assert "--unshare-net" not in build_bwrap_argv(
-        default_policy(project, allow_network=True), ["true"]
-    )
-
-
 def test_degrades_visibly_when_no_backend(project: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     """A sandbox that silently does nothing is worse than a visible absence."""
     monkeypatch.setattr("platform.system", lambda: "Haiku")
@@ -96,14 +86,6 @@ def test_degrades_visibly_when_no_backend(project: Path, monkeypatch: pytest.Mon
     assert sandbox.wrap(["echo", "hi"]) == ["echo", "hi"]
 
 
-@pytest.mark.sandbox
-@pytest.mark.skipif(detect_backend() is SandboxBackend.NONE, reason="no sandbox backend")
-def test_write_inside_the_project_still_works(project: Path) -> None:
-    sandbox = Sandbox(default_policy(project))
-    _run(sandbox, f"echo inside > {project}/ok.txt")
-    assert (project / "ok.txt").exists()
-
-
 @pytest.mark.sandbox
 @pytest.mark.skipif(detect_backend() is SandboxBackend.NONE, reason="no sandbox backend")
 def test_write_outside_project_is_blocked(project: Path) -> None:
@@ -142,11 +124,3 @@ def test_denied_paths_cannot_be_read(project: Path) -> None:
 def test_network_is_blocked_by_default(project: Path) -> None:
     sandbox = Sandbox(default_policy(project, allow_network=False))
     assert _run(sandbox, "curl -sS -m 5 https://example.com").returncode != 0
-
-
-@pytest.mark.sandbox
-@pytest.mark.skipif(detect_backend() is SandboxBackend.NONE, reason="no sandbox backend")
-def test_ordinary_work_is_not_broken(project: Path) -> None:
-    """A sandbox that blocks real work gets turned off, which protects nothing."""
-    result = _run(Sandbox(default_policy(project)), "ls / >/dev/null && python3 -c 'print(1+1)'")
-    assert result.stdout.strip() == "2"

hx_cli-0.1.4/tests/test_install.py

@@ -0,0 +1,53 @@
+"""Installer presentation and smoke tests."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).parent.parent
+
+
+def test_installer_shows_the_hx_banner_features_and_support_contact(
+    tmp_path: Path,
+) -> None:
+    """A successful install should summarize HX and leave a way to get help."""
+    fake_bin = tmp_path / "bin"
+    fake_bin.mkdir()
+
+    uv = fake_bin / "uv"
+    uv.write_text(
+        "#!/bin/sh\n"
+        'case "$1 $2" in\n'
+        "  '--version ') echo 'uv 0.test' ;;\n"
+        "  'tool install') exit 0 ;;\n"
+        "esac\n"
+    )
+    uv.chmod(0o755)
+
+    hx = fake_bin / "hx"
+    hx.write_text("#!/bin/sh\nexit 0\n")
+    hx.chmod(0o755)
+
+    env = os.environ.copy()
+    env["PATH"] = f"{fake_bin}:{env['PATH']}"
+    result = subprocess.run(
+        ["sh", str(ROOT / "install.sh")],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+    assert "|_| |_|/_/  \\_\\" in result.stdout
+    assert "HX is a terminal coding agent that works inside your project." in result.stdout
+    assert "handles larger tasks with persistent sessions, skills, tools, and subagents" in (
+        result.stdout
+    )
+    assert "see context, cost, and usage for every turn" in result.stdout
+    assert "project.\n  It reads and edits files, runs commands in a sandbox" in result.stdout
+    assert "subagents.\n  Connect to models through OpenRouter" in result.stdout
+    assert "HX Installer" not in result.stdout
+    assert "Questions or issues? Contact \x1b[1;33miam@sunilaleti.dev\x1b[0m" in (result.stdout)
+    assert "Done. Run 'hx' inside a project directory." in result.stdout

hx_cli-0.1.4/tests/tools/test_output.py

@@ -0,0 +1,31 @@
+"""Tool output capping."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from hx.tools.output import cap_output
+
+
+def test_small_output_passes_through() -> None:
+    result = cap_output("hello", session_id="s", tool_use_id="t")
+    assert result.text == "hello"
+    assert not result.truncated
+    assert result.spilled_path is None
+
+
+def test_spill_path_cannot_escape_the_outputs_directory(hx_home: Path) -> None:
+    """Tool ids come from the model and must not be trusted as filenames."""
+    from hx.paths import session_outputs_dir
+    from hx.tools.output import spill
+
+    path = spill("body", "sess", "../../escape")
+    assert path.parent == session_outputs_dir("sess")
+
+
+def test_summary_reports_the_first_line_and_a_count() -> None:
+    from hx.tools.output import summarize_for_ui
+
+    assert summarize_for_ui("only line") == "only line"
+    assert summarize_for_ui("first\nsecond\nthird") == "first (+2 lines)"
+    assert summarize_for_ui("   ") == "no output"