cc-session-tools 3.7.0__tar.gz → 3.7.1__tar.gz

{cc_session_tools-3.7.0/src/cc_session_tools.egg-info → cc_session_tools-3.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 3.7.0
+Version: 3.7.1
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)
 Author: raffishquartan
 License: MIT License

{cc_session_tools-3.7.0 → cc_session_tools-3.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cc-session-tools"
-version = "3.7.0"
+version = "3.7.1"
 description = "Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)"
 readme = "README.md"
 license = { file = "LICENSE" }

{cc_session_tools-3.7.0 → cc_session_tools-3.7.1}/src/cc_session_tools/cli/ccst.py

@@ -112,6 +112,7 @@ from cc_session_tools.hooks_install import (
 )
 from cc_session_tools.lib import machine_identity
 from cc_session_tools.lib.hook_registry import HOOK_DESCRIPTIONS, HOOK_VERBS
+from cc_session_tools.lib.text_wrap import wrap_block
 
 if TYPE_CHECKING:
     # Type-only, so the handler's own lazy `from ... import sync_check` (this file's convention:
@@ -538,30 +539,45 @@ def _bundle_inventory(bundle: dict[str, Any]) -> list[tuple[str, str, str | None
     return out
 
 
-def _print_hooks_install_table(
+def _format_hooks_install_records(
     inventory: list[tuple[str, str, str | None, str]],
     added_keys: set[tuple[str, str | None, str]],
-) -> None:
-    """Print a Hook | Status | Event | Description table to stdout."""
-    headers = ("Hook", "Status", "Event", "Description")
-    if not inventory:
-        return
+) -> str:
+    """One record per hook: a `name  status` header, an indented `Events:` line, then the
+    indented, terminal-width-wrapped description. Records are separated by a blank line.
 
-    rows: list[tuple[str, str, str, str]] = []
+    A hook registered for several events is one record; when only some of its registrations
+    would be added, those events carry a `(new)` marker. Order follows the inventory (sorted by
+    hook name).
+    """
+    by_hook: dict[str, list[tuple[bool, str]]] = {}
     for name, event, matcher, cmd in inventory:
-        status = "install" if (event, matcher, cmd) in added_keys else "already-installed"
         event_label = f"{event}[{matcher}]" if matcher else event
+        by_hook.setdefault(name, []).append(((event, matcher, cmd) in added_keys, event_label))
+
+    records: list[str] = []
+    for name, registrations in by_hook.items():
+        any_new = any(is_new for is_new, _ in registrations)
+        mixed = any_new and not all(is_new for is_new, _ in registrations)
+        status = "install" if any_new else "already-installed"
+        events = ", ".join(
+            f"{label} (new)" if mixed and is_new else label for is_new, label in registrations
+        )
+        lines = [f"{name}  {status}", wrap_block(f"Events: {events}")]
         description = HOOK_DESCRIPTIONS.get(name, "")
-        rows.append((name, status, event_label, description))
+        if description:
+            lines.append(wrap_block(description))
+        records.append("\n".join(lines))
+    return "\n\n".join(records)
 
-    widths = [
-        max([len(headers[i])] + [len(r[i]) for r in rows]) for i in range(4)
-    ]
-    fmt = f"{{:<{widths[0]}}}  {{:<{widths[1]}}}  {{:<{widths[2]}}}  {{:<{widths[3]}}}"
-    print(fmt.format(*headers))
-    print(fmt.format(*("-" * w for w in widths)))
-    for row in rows:
-        print(fmt.format(*row))
+
+def _print_hooks_install_table(
+    inventory: list[tuple[str, str, str | None, str]],
+    added_keys: set[tuple[str, str | None, str]],
+) -> None:
+    """Print the per-hook install records to stdout."""
+    if inventory:
+        print(_format_hooks_install_records(inventory, added_keys))
 
 
 def _list_bundle_hook_names(bundle: dict[str, Any]) -> list[str]:

{cc_session_tools-3.7.0 → cc_session_tools-3.7.1}/src/cc_session_tools/lib/doctor.py

@@ -14,7 +14,6 @@ import os
 import shutil
 import sqlite3
 import subprocess
-import textwrap
 import time
 from dataclasses import dataclass
 from enum import Enum
@@ -29,6 +28,7 @@ from cc_session_tools.lib.pdata.init_paths import (
     MIGRATED_ARCHIVE_DIRNAME,
     MIGRATED_MANIFEST_FILENAME,
 )
+from cc_session_tools.lib.text_wrap import wrap_block
 
 if TYPE_CHECKING:
     from cc_session_tools.lib.install_sync import FailedAttempt
@@ -1224,12 +1224,11 @@ def _wrap_reason(reason: str, *, indent: str = "    ") -> str:
     embedded paths and remediation commands); printed on a single line they
     hard-wrap at the terminal edge with no continuation indent, making a
     wrapped reason indistinguishable from a new, unrelated result. Wrapping
-    to the real terminal width — falling back to 80 columns for non-tty
+    to the real terminal width - falling back to 80 columns for non-tty
     output (piped, redirected, or the scheduled drift-monitor job whose
-    stdout is forwarded to Telegram) — and indenting every line fixes that.
+    stdout is forwarded to Telegram) - and indenting every line fixes that.
     """
-    width = shutil.get_terminal_size(fallback=(80, 24)).columns
-    return textwrap.fill(reason, width=width, initial_indent=indent, subsequent_indent=indent)
+    return wrap_block(reason, indent=indent)
 
 
 def format_results(results: list[CheckResult], *, show_all: bool = False) -> str:
@@ -1265,7 +1264,13 @@ def format_results(results: list[CheckResult], *, show_all: bool = False) -> str
         lines.append(f"All {len(results)} checks OK.")
     has_issues = any(r.status in (Status.WARN, Status.FAIL) for r in results)
     if has_issues:
-        lines.append("\nTip: run `ccst install-everything --apply` to sync skills, hooks, shell, and CLAUDE.md")
+        lines.append("")
+        lines.append(
+            wrap_block(
+                "Tip: run `ccst install-everything --apply` to sync skills, hooks, shell, and CLAUDE.md",
+                indent="",
+            )
+        )
     if not show_all:
         lines.append("\nTo see full doctor output use --all argument")
     return "\n".join(lines)

cc_session_tools-3.7.1/src/cc_session_tools/lib/text_wrap.py

@@ -0,0 +1,35 @@
+"""Terminal-width word wrapping shared by `ccst doctor` and the hooks install output."""
+from __future__ import annotations
+
+import shutil
+import textwrap
+
+FALLBACK_WIDTH = 80
+MIN_WIDTH = 40
+
+
+def effective_width() -> int:
+    """Width to wrap to: the detected terminal width, never below MIN_WIDTH.
+
+    `shutil.get_terminal_size` reads `COLUMNS`, then the real terminal via the process's stdout
+    file descriptor (so an in-process `redirect_stdout` capture still sees the real terminal),
+    and falls back to FALLBACK_WIDTH when neither is available. It is called through the module
+    attribute so tests can patch it.
+    """
+    return max(shutil.get_terminal_size(fallback=(FALLBACK_WIDTH, 24)).columns, MIN_WIDTH)
+
+
+def wrap_block(text: str, *, indent: str = "    ") -> str:
+    """Word-wrap `text` to the effective width, indenting every line.
+
+    Words are never split: a path, hyphenated name or backticked command that has no whitespace
+    stays on one line, and a single token longer than the width overflows rather than breaking.
+    """
+    return textwrap.fill(
+        text,
+        width=effective_width(),
+        initial_indent=indent,
+        subsequent_indent=indent,
+        break_long_words=False,
+        break_on_hyphens=False,
+    )

{cc_session_tools-3.7.0 → cc_session_tools-3.7.1/src/cc_session_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 3.7.0
+Version: 3.7.1
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)
 Author: raffishquartan
 License: MIT License

{cc_session_tools-3.7.0 → cc_session_tools-3.7.1}/src/cc_session_tools.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ src/cc_session_tools/lib/sessions_repair.py
 src/cc_session_tools/lib/shell_install.py
 src/cc_session_tools/lib/tasklist.py
 src/cc_session_tools/lib/telemetry_store.py
+src/cc_session_tools/lib/text_wrap.py
 src/cc_session_tools/lib/messaging/__init__.py
 src/cc_session_tools/lib/messaging/addressing.py
 src/cc_session_tools/lib/messaging/cursor.py
@@ -247,6 +248,7 @@ tests/test_doctor_mutes.py
 tests/test_empty_session.py
 tests/test_hook_cache.py
 tests/test_hooks_install.py
+tests/test_hooks_install_records.py
 tests/test_install_sync.py
 tests/test_last_screenshot.py
 tests/test_levenshtein.py
@@ -282,5 +284,6 @@ tests/test_sessions_repair.py
 tests/test_tasklist.py
 tests/test_telemetry.py
 tests/test_telemetry_store.py
+tests/test_text_wrap.py
 tests/test_transcript.py
 tests/test_worklog_guard.py

{cc_session_tools-3.7.0 → cc_session_tools-3.7.1}/tests/test_ccst_doctor.py

@@ -687,6 +687,29 @@ def test_wrap_reason_indents_every_line(monkeypatch: pytest.MonkeyPatch) -> None
     assert all(line.startswith("    ") for line in lines)
 
 
+def test_wrap_reason_does_not_split_paths_or_hyphenated_names(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(shutil, "get_terminal_size", lambda fallback=(80, 24): os.terminal_size((60, 24)))
+    path = "/home/alice/.local/share/claude/claude-flags.json"
+    out = _wrap_reason(f"not yet created; will be created at {path} on first use")
+    assert path in out.split()
+
+
+def test_wrap_reason_width_floor_is_40(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(shutil, "get_terminal_size", lambda fallback=(80, 24): os.terminal_size((10, 24)))
+    lines = _wrap_reason("word " * 30).splitlines()
+    assert all(len(line) <= 40 for line in lines)
+    assert max(len(line) for line in lines) > 10
+
+
+def test_format_results_tip_line_wraps_at_80_columns(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(shutil, "get_terminal_size", lambda fallback=(80, 24): os.terminal_size((80, 24)))
+    out = format_results([CheckResult("foo", Status.WARN, "bad")])
+    tip_lines = out.split("Tip: ", 1)[1].split("\n\n", 1)[0].splitlines()
+    assert "Tip: run `ccst install-everything --apply`" in out
+    assert len(tip_lines) > 1
+    assert all(len(line) <= 80 for line in ["Tip: " + tip_lines[0], *tip_lines[1:]])
+
+
 # ---------- format_drift_report ----------
 
 def test_format_drift_report_empty_returns_empty_string() -> None:

{cc_session_tools-3.7.0 → cc_session_tools-3.7.1}/tests/test_ccst_hooks_install_zero_arg.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -9,15 +10,32 @@ from pathlib import Path
 import pytest
 
 
-def _run(*args: str, cwd: str | None = None) -> subprocess.CompletedProcess[str]:
+def _run(
+    *args: str, cwd: str | None = None, columns: str | None = "80"
+) -> subprocess.CompletedProcess[str]:
+    """Run ccst with COLUMNS pinned (None removes it) so the developer's shell can't change the width."""
+    env = {k: v for k, v in os.environ.items() if k != "COLUMNS"}
+    if columns is not None:
+        env["COLUMNS"] = columns
     return subprocess.run(
         [sys.executable, "-m", "cc_session_tools.cli.ccst", *args],
         capture_output=True,
         text=True,
         cwd=cwd or str(Path(__file__).parent.parent),
+        env=env,
     )
 
 
+def _record(stdout: str, name: str) -> list[str]:
+    """The lines of `name`'s record: its column-0 header plus the indented lines below it."""
+    lines = stdout.splitlines()
+    start = next(i for i, ln in enumerate(lines) if ln.startswith(f"{name} "))
+    end = start + 1
+    while end < len(lines) and lines[end].startswith("    "):
+        end += 1
+    return lines[start:end]
+
+
 def _write(path: Path, data: dict) -> None:
     path.write_text(json.dumps(data, indent=2))
 
@@ -225,15 +243,30 @@ ALL_HOOK_NAMES = (
 )
 
 
-def test_hooks_install_table_has_expected_headers(tmp_path: Path) -> None:
-    """The table has Hook/Status/Event/Description column headers."""
+def test_hooks_install_records_have_events_line_and_no_column_titles(tmp_path: Path) -> None:
+    """Each hook is a record: header line, indented `Events:` line, indented description."""
     tgt = tmp_path / "settings.json"
     _write(tgt, {})
     result = _run("hooks", "install", "--target", str(tgt))
     assert result.returncode == 0, result.stderr
-    out = result.stdout
-    for header in ("Hook", "Status", "Event", "Description"):
-        assert header in out, f"missing header {header!r} in:\n{out}"
+    for name in ALL_HOOK_NAMES:
+        record = _record(result.stdout, name)
+        assert record[1].startswith("    Events: "), record
+        assert len(record) >= 3, record
+    assert "Description" not in result.stdout
+    assert "-----" not in result.stdout
+
+
+def test_hooks_install_output_respects_terminal_width(tmp_path: Path) -> None:
+    """No indented record line exceeds COLUMNS; with COLUMNS unset the fallback is 80."""
+    tgt = tmp_path / "settings.json"
+    _write(tgt, {})
+    for columns, limit in (("80", 80), ("120", 120), (None, 80)):
+        result = _run("hooks", "install", "--target", str(tgt), columns=columns)
+        assert result.returncode == 0, result.stderr
+        for ln in result.stdout.splitlines():
+            if ln.startswith("    "):
+                assert len(ln) <= limit, f"COLUMNS={columns}: {ln!r}"
 
 
 def test_hooks_install_table_lists_all_bundled_hooks(tmp_path: Path) -> None:
@@ -291,11 +324,14 @@ def test_hooks_install_table_shows_descriptions(tmp_path: Path) -> None:
     tgt = tmp_path / "settings.json"
     _write(tgt, {})
     result = _run("hooks", "install", "--target", str(tgt))
-    # Spot-check that the description column carries meaningful text per hook
-    assert "shell commands" in result.stdout  # bash-security-review
-    assert "8-digit confirmation" in result.stdout
-    assert "last-active" in result.stdout  # after-response
-    assert "session tag" in result.stdout
+    # Descriptions wrap by width, so compare against each record's lines joined together
+    def text(name: str) -> str:
+        return " ".join(" ".join(_record(result.stdout, name)[2:]).split())
+
+    assert "shell commands" in text("bash-security-review")
+    assert "8-digit confirmation" in text("confirm-8digit")
+    assert "last-active" in text("after-response")
+    assert "session tag" in text("session-tag")
 
 
 def test_hooks_install_hook_selector_table_only_named_row(tmp_path: Path) -> None:

cc_session_tools-3.7.1/tests/test_hooks_install_records.py

@@ -0,0 +1,104 @@
+"""Record layout of the hooks install output (`_format_hooks_install_records`)."""
+from __future__ import annotations
+
+import os
+import shutil
+
+import pytest
+
+from cc_session_tools.cli.ccst import _format_hooks_install_records
+
+Inv = list[tuple[str, str, str | None, str]]
+
+
+def _width(monkeypatch: pytest.MonkeyPatch, columns: int) -> None:
+    monkeypatch.setattr(
+        shutil, "get_terminal_size", lambda fallback=(80, 24): os.terminal_size((columns, 24))
+    )
+
+
+def _inv() -> Inv:
+    return [
+        ("catchup", "SessionStart", None, "ccst hooks run catchup"),
+        ("catchup", "UserPromptSubmit", None, "ccst hooks run catchup"),
+        ("confirm-8digit", "PreToolUse", None, "ccst hooks run confirm-8digit"),
+    ]
+
+
+def test_one_record_per_hook_name(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 80)
+    out = _format_hooks_install_records(_inv(), set())
+    headers = [ln for ln in out.splitlines() if ln and not ln.startswith(" ")]
+    assert [h.split()[0] for h in headers] == ["catchup", "confirm-8digit"]
+
+
+def test_record_shape_and_blank_line_separation(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 80)
+    out = _format_hooks_install_records(_inv(), set())
+    assert not out.endswith("\n")
+    first, second = out.split("\n\n")
+    lines = first.splitlines()
+    assert lines[0].startswith("catchup ")
+    assert lines[1] == "    Events: SessionStart, UserPromptSubmit"
+    assert all(ln.startswith("    ") for ln in lines[1:])
+    assert second.splitlines()[0].startswith("confirm-8digit ")
+    assert "Description" not in out and "---" not in out
+
+
+def test_description_printed_once_for_multi_event_hook(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 200)
+    out = _format_hooks_install_records(_inv(), set())
+    assert out.count("Reconciles+launches") == 1
+
+
+def test_status_all_new_and_all_installed(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 80)
+    inv = _inv()
+    added = {(e, m, c) for _, e, m, c in inv}
+    new = _format_hooks_install_records(inv, added)
+    assert new.splitlines()[0].split()[1] == "install"
+    assert "(new)" not in new
+    old = _format_hooks_install_records(inv, set())
+    assert old.splitlines()[0].split()[1] == "already-installed"
+
+
+def test_partly_installed_multi_event_hook_marks_new_events(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _width(monkeypatch, 80)
+    added: set[tuple[str, str | None, str]] = {("UserPromptSubmit", None, "ccst hooks run catchup")}
+    out = _format_hooks_install_records(_inv(), added)
+    lines = out.splitlines()
+    assert lines[0].split()[1] == "install"
+    assert lines[1] == "    Events: SessionStart, UserPromptSubmit (new)"
+
+
+def test_no_events_or_description_line_exceeds_width(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 80)
+    from cc_session_tools.lib.hook_registry import HOOK_DESCRIPTIONS
+
+    inv: Inv = [(n, "SessionStart", None, f"ccst hooks run {n}") for n in HOOK_DESCRIPTIONS]
+    out = _format_hooks_install_records(inv, set())
+    for ln in out.splitlines():
+        if ln.startswith("    "):
+            assert len(ln) <= 80, ln
+
+
+def test_no_description_prints_header_and_events_only(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 80)
+    cmd = "/opt/tools/run-thing.sh --flag value"
+    out = _format_hooks_install_records([(cmd, "Stop", None, cmd)], set())
+    lines = out.splitlines()
+    assert lines[0].startswith(cmd)
+    assert lines[1] == "    Events: Stop"
+    assert len(lines) == 2
+
+
+def test_matcher_in_event_label(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 80)
+    inv: Inv = [("marker-allow", "PreToolUse", "Bash", "ccst hooks run marker-allow")]
+    assert "Events: PreToolUse[Bash]" in _format_hooks_install_records(inv, set())
+
+
+def test_empty_inventory_is_empty_string() -> None:
+    assert _format_hooks_install_records([], set()) == ""

cc_session_tools-3.7.1/tests/test_text_wrap.py

@@ -0,0 +1,70 @@
+"""Shared terminal-width wrapping used by `ccst doctor` and the hooks install output."""
+from __future__ import annotations
+
+import os
+import shutil
+
+import pytest
+
+from cc_session_tools.lib import text_wrap
+
+
+def _width(monkeypatch: pytest.MonkeyPatch, columns: int) -> None:
+    monkeypatch.setattr(
+        shutil, "get_terminal_size", lambda fallback=(80, 24): os.terminal_size((columns, 24))
+    )
+
+
+def test_wraps_to_detected_width(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 80)
+    out = text_wrap.wrap_block("word " * 60)
+    lines = out.splitlines()
+    assert len(lines) > 1
+    assert all(len(line) <= 80 for line in lines)
+
+
+def test_wide_terminal_wraps_to_fewer_lines(monkeypatch: pytest.MonkeyPatch) -> None:
+    text = "word " * 60
+    _width(monkeypatch, 80)
+    narrow = len(text_wrap.wrap_block(text).splitlines())
+    _width(monkeypatch, 200)
+    wide = len(text_wrap.wrap_block(text).splitlines())
+    assert wide < narrow
+
+
+def test_every_line_carries_the_indent(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 60)
+    lines = text_wrap.wrap_block("word " * 40, indent="      ").splitlines()
+    assert len(lines) > 1
+    assert all(line.startswith("      ") and not line.startswith("       ") for line in lines)
+
+
+def test_width_floor_is_40_columns(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 20)
+    assert text_wrap.effective_width() == 40
+    lines = text_wrap.wrap_block("word " * 40).splitlines()
+    assert max(len(line) for line in lines) > 20
+    assert all(len(line) <= 40 for line in lines)
+
+
+def test_non_tty_fallback_is_80_columns(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        shutil, "get_terminal_size", lambda fallback=(80, 24): os.terminal_size(fallback)
+    )
+    assert text_wrap.effective_width() == 80
+
+
+def test_path_and_hyphenated_name_are_never_split(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 40)
+    path = "/Users/x/.local/share/claude/claude-flags.json"
+    text = "not yet created; will be created at " + path + " on first use"
+    out = text_wrap.wrap_block(text)
+    assert path in out.split()
+    assert "context-window-warning" in text_wrap.wrap_block("nudge from " * 3 + "context-window-warning")
+
+
+def test_overlong_token_overflows_unsplit(monkeypatch: pytest.MonkeyPatch) -> None:
+    _width(monkeypatch, 40)
+    token = "x" * 70
+    lines = text_wrap.wrap_block(f"see {token} now").splitlines()
+    assert any(line.strip() == token for line in lines)