langstage-cli 0.6.45__tar.gz → 0.6.47__tar.gz

{langstage_cli-0.6.45/langstage_cli.egg-info → langstage_cli-0.6.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langstage-cli
-Version: 0.6.45
+Version: 0.6.47
 Summary: The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph
 Author-email: Kedar Dabhadkar <kdabhadk@gmail.com>
 License-Expression: MIT

{langstage_cli-0.6.45 → langstage_cli-0.6.47}/langstage_cli/cli.py

@@ -8,6 +8,7 @@ import copy
 import json
 import os
 import re
+import signal
 import subprocess
 import sys
 import threading
@@ -1001,6 +1002,15 @@ def _default_agent_path() -> Optional[Path]:
     return path if path.exists() else None
 
 
+# A MESSAGE that is really an agent spec: ``my_agent.py:graph`` or ``pkg.module:agent``.
+_SPEC_LIKE = re.compile(r"^(?:(?:[A-Za-z]:)?[^\s:]+\.py|[A-Za-z_][\w.]*):[A-Za-z_]\w*$")
+
+
+def _looks_like_agent_spec(message: Optional[str]) -> bool:
+    """Whether a positional MESSAGE looks like an agent spec meant for ``-a`` (gh #186)."""
+    return bool(message) and bool(_SPEC_LIKE.match(message.strip()))
+
+
 def _no_agent_toml_hint(cfg: Any, toml_sources: list) -> List[str]:
     """Lines explaining why a ``langstage.toml`` that was read supplied no spec (gh #148).
 
@@ -1732,7 +1742,7 @@ def _select_option_typed(options: List[str], prompt: str) -> int:
         print(f"  {i}. {opt}")
     while True:
         try:
-            raw = input(f"Choose 1-{len(options)} [1]: ").strip()
+            raw = _prompt_line(f"Choose 1-{len(options)} [1]: ").strip()
         except (KeyboardInterrupt, EOFError):
             print()
             sys.exit(EXIT_PAUSED)
@@ -1743,6 +1753,25 @@ def _select_option_typed(options: List[str], prompt: str) -> int:
         print(f"Enter a number from 1 to {len(options)}.")
 
 
+def _prompt_line(prompt: str) -> str:
+    """``input()`` at an approval prompt, where one Ctrl-C raises ``KeyboardInterrupt``.
+
+    The approval prompts run inside the turn's ``asyncio.run``, whose SIGINT handler
+    (Python 3.11+) only schedules a task cancel on the first Ctrl-C. A blocking
+    ``input()`` never yields to the loop, so that press was swallowed and only a
+    second one exited (gh #189). The default handler is put back for the duration of
+    the read, so the first press reaches the caller's ``except KeyboardInterrupt``.
+    """
+    try:
+        previous = signal.signal(signal.SIGINT, signal.default_int_handler)
+    except ValueError:  # not the main thread: signal handlers can't be changed here
+        return input(prompt)
+    try:
+        return input(prompt)
+    finally:
+        signal.signal(signal.SIGINT, previous)
+
+
 def handle_interrupt_input(num_actions: int = 1, is_generic: bool = False) -> Any:
     """
     Handle user input for an interrupt using arrow key navigation, returning the
@@ -1834,7 +1863,7 @@ def _approval_input() -> str:
     turn stays paused on the interrupt, so exit 2 (ADR 0007, gh #174).
     """
     try:
-        return input(make_prompt("❯", BLUE))
+        return _prompt_line(make_prompt("❯", BLUE))
     except (KeyboardInterrupt, EOFError):
         print()
         sys.exit(EXIT_PAUSED)
@@ -1963,7 +1992,8 @@ def cmd_status(args: str, context: Dict[str, Any]) -> Optional[str]:
     print(f"\n{BOLD}{BRIGHT_CYAN}Session Status{RESET}")
     print(f"{DIM}{'─' * 30}{RESET}")
     print(f"  {DIM}Agent:{RESET}       {agent_name}")
-    print(f"  {DIM}Thread ID:{RESET}   {thread_id[:8]}...")
+    shown_id = sessions.display_id(thread_id)
+    print(f"  {DIM}Thread ID:{RESET}   {shown_id}{'...' if shown_id != thread_id else ''}")
     # No "Mode: async/sync" line: since ADR 0003 there is exactly one (async) path,
     # so the value was reporting a distinction the runtime does not have (gh #88).
     print(f"  {DIM}Verbose:{RESET}     {'on' if verbose else 'off'}")
@@ -2835,7 +2865,8 @@ def _resolve_resume_thread(
         matches = sessions.match_threads(workspace, resume_id)
         if len(matches) > 1:
             # An ambiguous prefix is not "no match" (gh #124): say so and list them.
-            shown = ", ".join(t[:8] for t in matches[:10])
+            # Each match in a form --resume accepts and that tells them apart (gh #188).
+            shown = ", ".join(sessions.display_id(t, matches) for t in matches[:10])
             more = f", +{len(matches) - 10} more" if len(matches) > 10 else ""
             _status(
                 f"{RED}⏺ Error: prefix '{resume_id}' is ambiguous — it matches "
@@ -2855,7 +2886,7 @@ def _resolve_resume_thread(
         # The session's state lives in the agent's own checkpointer (gh #128): the CLI
         # holds no history for it, so the resume restores only what that checkpointer kept.
         _status(
-            f"{YELLOW}note: session {thread[:8]} ran on the agent's own checkpointer; "
+            f"{YELLOW}note: session {sessions.display_id(thread)} ran on the agent's own checkpointer; "
             f"the CLI stored no history for it, so this resume restores only what that "
             f"checkpointer kept (nothing, if it is in-memory).{RESET}"
         )
@@ -3039,6 +3070,9 @@ def _print_sessions(workspace: Path) -> None:
         return
     print(f"\n{BOLD}{BRIGHT_CYAN}Sessions{RESET} {DIM}({workspace}){RESET}")
     print(f"{DIM}{'─' * 40}{RESET}")
+    all_ids = [tid for tid, _ in rows]
+    shown = {tid: sessions.display_id(tid, all_ids) for tid in all_ids}
+    width = max(len(s) for s in shown.values())
     for tid, entry in rows:
         when = _format_ts(entry.get("updated"))
         first = entry.get("first_message") or f"{DIM}(no message yet){RESET}"
@@ -3049,7 +3083,9 @@ def _print_sessions(workspace: Path) -> None:
             if entry.get("checkpointer") == "agent"
             else ""
         )
-        print(f"  {CYAN}{tid[:8]}{RESET}  {DIM}{when}{RESET}  {first}{mark}")
+        # A pinned id is shown in full and a minted UUID by its shortest unique prefix, so
+        # two sessions never look alike and each shown id works with --resume (gh #188).
+        print(f"  {CYAN}{shown[tid]:<{width}}{RESET}  {DIM}{when}{RESET}  {first}{mark}")
     print(f"\n{DIM}Resume with:  langstage-cli --resume <id>  (or -c for the most recent){RESET}\n")
 
 
@@ -3468,10 +3504,18 @@ def main(
                 # of only pointing at the env var (gh #148).
                 for line in _no_agent_toml_hint(cfg, toml_sources):
                     _status(f"{YELLOW}{line}{RESET}")
+                # The spec went in as the MESSAGE: name the command that works (gh #186).
+                if _looks_like_agent_spec(message):
+                    _status(
+                        f"{YELLOW}The agent spec goes after -a: langstage-cli -a {message.strip()}{RESET}"
+                    )
                 _status(f"\n{DIM}Usage:{RESET}")
-                _status("  langstage-cli path/to/agent.py:graph")
-                _status("  langstage-cli mypackage.module:agent")
-                _status(f"\n{DIM}Or set the LANGSTAGE_AGENT_SPEC environment variable{RESET}")
+                _status("  langstage-cli -a path/to/agent.py:graph")
+                _status("  langstage-cli -a mypackage.module:agent")
+                _status(
+                    f"\n{DIM}Or set LANGSTAGE_AGENT_SPEC, put the spec under [agent] spec in "
+                    f"langstage.toml, or run `langstage-cli init` for a starter agent{RESET}"
+                )
                 sys.exit(1)
 
         # The BASE directory a relative spec resolves against depends on WHERE it came
@@ -3585,7 +3629,7 @@ def main(
                 if use_durable:
                     persist_sqlite_path = _snapshot_session_store(workspace)
                 _status(
-                    f"{DIM}⏺ --no-persist: resuming session {session_thread[:8]} read-only — "
+                    f"{DIM}⏺ --no-persist: resuming session {sessions.display_id(session_thread)} read-only — "
                     f"this run will not be saved.{RESET}"
                 )
             if persist_sqlite_path is None and use_durable:

{langstage_cli-0.6.45 → langstage_cli-0.6.47}/langstage_cli/sessions.py

@@ -26,9 +26,10 @@ Two pieces live here:
 import hashlib
 import json
 import os
+import re
 import time
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, Iterable, List, Optional, Tuple
 
 from langstage_core.host.config import _global_toml_path
 
@@ -40,6 +41,10 @@ _SESSIONS_DIR_ENV = "LANGSTAGE_CLI_SESSIONS_DIR"
 
 _SNIPPET_MAX = 60
 
+# The ids the CLI mints itself (uuid4). Only these are shortened for display.
+_UUID_RE = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
+_SHORT_ID_MIN = 8
+
 
 def _config_home() -> Path:
     """The LangStage config home — ``LANGSTAGE_CONFIG_HOME`` (then legacy
@@ -185,8 +190,8 @@ def most_recent_thread(workspace: Path) -> Optional[str]:
 def resolve_thread(workspace: Path, ref: str) -> Optional[str]:
     """Resolve a ``--resume`` reference to a full thread id.
 
-    Accepts an exact id or an unambiguous prefix (ids are UUIDs; ``--list-sessions``
-    shows short forms). Returns the full id, or ``None`` if it matches nothing / is
+    Accepts an exact id or an unambiguous prefix (``--list-sessions`` shows CLI-minted
+    UUIDs in a short form, see ``display_id``). Returns the full id, or ``None`` if it matches nothing / is
     ambiguous.
     """
     matches = match_threads(workspace, ref)
@@ -208,6 +213,24 @@ def match_threads(workspace: Path, ref: str) -> List[str]:
     return [tid for tid, _ in matches]
 
 
+def display_id(thread_id: str, others: Iterable[str] = ()) -> str:
+    """How a session id is printed (gh #188).
+
+    A CLI-minted UUID is shortened to its shortest prefix of at least 8 characters
+    that no id in ``others`` shares, like ``git log --abbrev``. Any other id (a pinned
+    ``[configurable] thread_id`` the user named, e.g. ``project-alpha``) is printed in
+    full: such names often share a prefix, and the user has to type one back to
+    ``--resume``. Either form is accepted by ``--resume``.
+    """
+    if not _UUID_RE.match(thread_id):
+        return thread_id
+    rivals = [o for o in others if o != thread_id]
+    n = _SHORT_ID_MIN
+    while n < len(thread_id) and any(o.startswith(thread_id[:n]) for o in rivals):
+        n += 1
+    return thread_id[:n]
+
+
 def list_sessions(workspace: Path) -> List[Tuple[str, dict]]:
     """All sessions for this workspace, most-recently-updated first."""
     sessions = load_index(workspace)

{langstage_cli-0.6.45 → langstage_cli-0.6.47/langstage_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langstage-cli
-Version: 0.6.45
+Version: 0.6.47
 Summary: The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph
 Author-email: Kedar Dabhadkar <kdabhadk@gmail.com>
 License-Expression: MIT

{langstage_cli-0.6.45 → langstage_cli-0.6.47}/langstage_cli.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ tests/test_quiet_output.py
 tests/test_reasoning_render.py
 tests/test_rename_shim.py
 tests/test_render_markdown.py
+tests/test_routine_1024.py
 tests/test_session_lifecycle.py
 tests/test_sessions.py
 tests/test_show_config.py
@@ -64,6 +65,7 @@ tests/test_tool_output_escape.py
 tests/test_turn_error_verbose.py
 tests/test_turn_exit_and_render.py
 tests/test_unicode_console.py
+tests/test_usage_hint_186.py
 tests/test_verbose_command.py
 tests/test_verify_flag.py
 tests/test_workspace.py

{langstage_cli-0.6.45 → langstage_cli-0.6.47}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "langstage-cli"
-version = "0.6.45"
+version = "0.6.47"
 description = "The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph"
 readme = "README.md"
 requires-python = ">=3.11"

langstage_cli-0.6.47/tests/test_routine_1024.py

@@ -0,0 +1,122 @@
+"""gh #188: session ids are printed so they can be told apart and typed back.
+gh #189: one Ctrl-C at a typed approval prompt exits 2.
+
+- ``--list-sessions`` and the ambiguous-``--resume`` error cut every id to 8
+  characters, so pinned ``[configurable] thread_id``s sharing a prefix
+  (``project-alpha`` / ``project-beta``) both showed as ``project-``. A pinned id is
+  now shown in full and a CLI-minted UUID by its shortest unique prefix.
+- The typed prompts (``TERM=dumb`` menu, free-text reply, custom JSON) block in
+  ``input()`` inside the turn's ``asyncio.run``, whose SIGINT handler only schedules a
+  cancel on the first press, so that press was swallowed.
+"""
+
+import asyncio
+import signal
+import uuid
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+from langstage_cli import cli, sessions
+from langstage_cli.cli import main
+from langstage_cli.exit_codes import EXIT_PAUSED
+
+
+def _ws(tmp_path, monkeypatch) -> Path:
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    monkeypatch.setenv("LANGSTAGE_CONFIG_HOME", str(tmp_path / "empty_home"))
+    monkeypatch.chdir(ws)
+    return ws.resolve()
+
+
+# --- gh #188 ---
+
+
+def test_display_id_keeps_pinned_names_whole():
+    assert sessions.display_id("project-alpha", ["project-beta"]) == "project-alpha"
+    assert sessions.display_id("x") == "x"
+
+
+def test_display_id_shortens_minted_uuids_to_a_unique_prefix():
+    a = "abcdef12-0000-4000-8000-000000000001"
+    b = "abcdef12-3000-4000-8000-000000000002"
+    assert sessions.display_id(a) == "abcdef12"
+    assert sessions.display_id(a, [a]) == "abcdef12"  # itself is not a rival
+    assert sessions.display_id(a, [a, b]) == "abcdef12-0"
+    assert sessions.display_id(b, [a, b]) == "abcdef12-3"
+
+
+def test_list_sessions_shows_pinned_ids_in_full(tmp_path, monkeypatch):
+    ws = _ws(tmp_path, monkeypatch)
+    sessions.touch_session(ws, "project-alpha", first_message="alpha msg")
+    sessions.touch_session(ws, "project-beta", first_message="beta msg")
+    minted = str(uuid.uuid4())
+    sessions.touch_session(ws, minted, first_message="minted msg")
+    r = CliRunner().invoke(main, ["--demo", "--list-sessions"])
+    assert r.exit_code == 0, r.output
+    assert "project-alpha" in r.output and "project-beta" in r.output, r.output
+    assert minted[:8] in r.output and minted not in r.output, r.output
+
+
+def test_ambiguous_resume_lists_ids_resume_accepts(tmp_path, monkeypatch):
+    ws = _ws(tmp_path, monkeypatch)
+    sessions.touch_session(ws, "project-alpha", first_message="one")
+    sessions.touch_session(ws, "project-beta", first_message="two")
+    r = CliRunner().invoke(main, ["--demo", "--resume", "project-", "go"])
+    assert r.exit_code == 1, r.output
+    assert "project-alpha" in r.output and "project-beta" in r.output, r.output
+
+
+# --- gh #189 ---
+
+
+def _ctrl_c_then_answer(answer: str):
+    """An ``input()`` that gets one Ctrl-C mid-read, and would answer if it survived."""
+
+    def fake_input(prompt=""):
+        signal.raise_signal(signal.SIGINT)
+        return answer
+
+    return fake_input
+
+
+async def _in_loop(fn, *args):
+    return fn(*args)
+
+
+@pytest.mark.parametrize(
+    "call",
+    [
+        lambda: cli._select_option_typed(["Approve", "Reject"], "Proceed?"),
+        lambda: cli._approval_input(),
+    ],
+    ids=["dumb-term-menu", "reply-prompt"],
+)
+def test_one_ctrl_c_inside_asyncio_run_exits_paused(monkeypatch, call):
+    monkeypatch.setattr("builtins.input", _ctrl_c_then_answer("1"))
+    before = signal.getsignal(signal.SIGINT)
+    with pytest.raises(SystemExit) as e:
+        asyncio.run(_in_loop(call))
+    assert e.value.code == EXIT_PAUSED
+    assert signal.getsignal(signal.SIGINT) is before  # handler restored after the read
+
+
+def test_prompt_line_restores_the_loops_handler(monkeypatch):
+    seen = {}
+
+    def fake_input(prompt=""):
+        seen["during"] = signal.getsignal(signal.SIGINT)
+        return "ok"
+
+    monkeypatch.setattr("builtins.input", fake_input)
+
+    async def body():
+        outer = signal.getsignal(signal.SIGINT)
+        assert cli._prompt_line("> ") == "ok"
+        return outer, signal.getsignal(signal.SIGINT)
+
+    outer, after = asyncio.run(body())
+    assert seen["during"] is signal.default_int_handler
+    assert after is outer

langstage_cli-0.6.47/tests/test_usage_hint_186.py

@@ -0,0 +1,52 @@
+"""gh #186: the "No agent specified" hint shows commands that work (with -a)."""
+
+import pytest
+from click.testing import CliRunner
+
+from langstage_cli import cli
+from langstage_cli.cli import _looks_like_agent_spec, main
+
+
+@pytest.fixture
+def no_agent(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    for var in ("LANGSTAGE_AGENT_SPEC", "DEEPAGENT_AGENT_SPEC", "DEEPAGENT_SPEC"):
+        monkeypatch.delenv(var, raising=False)
+    monkeypatch.setattr(cli, "_default_agent_path", lambda: None)
+
+
+def test_usage_hint_uses_dash_a(no_agent):
+    r = CliRunner().invoke(main, ["hi"])
+    assert r.exit_code == 1, r.output
+    assert "No agent specified" in r.output
+    assert "langstage-cli -a path/to/agent.py:graph" in r.output
+    assert "langstage-cli -a mypackage.module:agent" in r.output
+    assert "[agent] spec" in r.output and "langstage-cli init" in r.output
+    # Not a spec-looking message: no "goes after -a" line.
+    assert "goes after -a" not in r.output
+
+
+@pytest.mark.parametrize("spec", ["my_agent.py:graph", "mypackage.module:agent"])
+def test_spec_passed_as_message_names_the_working_command(no_agent, spec):
+    r = CliRunner().invoke(main, [spec])
+    assert r.exit_code == 1, r.output
+    assert f"The agent spec goes after -a: langstage-cli -a {spec}" in r.output
+
+
+@pytest.mark.parametrize(
+    "message,expected",
+    [
+        ("my_agent.py:graph", True),
+        ("./agents/a.py:graph", True),
+        (r"C:\work\agent.py:graph", True),
+        ("pkg.module:agent", True),
+        ("hello", False),
+        ("what is 2:3", False),
+        ("ratio 3:1 please", False),
+        ("http://example.org:80", False),
+        ("", False),
+        (None, False),
+    ],
+)
+def test_looks_like_agent_spec(message, expected):
+    assert _looks_like_agent_spec(message) is expected