fbincon-claude-code-statusline 1.7.4__py3-none-any.whl

claude_statusline/__init__.py

@@ -0,0 +1,5 @@
+"""Packaged Claude Code status line for Linux, Windows and macOS."""
+
+from ._version import __version__
+
+__all__ = ["__version__"]

claude_statusline/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

claude_statusline/_platform.py

@@ -0,0 +1,117 @@
+"""Compatibility entry point; implementation lives in the documented subpackages."""
+
+from importlib import import_module
+
+_EXPORTS = {
+    "Iterator": ("claude_statusline.platforms.files", "Iterator"),
+    "Path": ("claude_statusline.platforms.files", "Path"),
+    "_DOTNET_FILETIME_OFFSET_TICKS": (
+        "claude_statusline.platforms.processes",
+        "_DOTNET_FILETIME_OFFSET_TICKS",
+    ),
+    "_MINUTE_NS": ("claude_statusline.platforms.clocks", "_MINUTE_NS"),
+    "_THREAD_LOCKS": ("claude_statusline.platforms.files", "_THREAD_LOCKS"),
+    "_THREAD_LOCKS_GUARD": ("claude_statusline.platforms.files", "_THREAD_LOCKS_GUARD"),
+    "_WINDOWS_RETRY_DELAYS": (
+        "claude_statusline.platforms.files",
+        "_WINDOWS_RETRY_DELAYS",
+    ),
+    "_WINDOWS_TRANSIENT_ERRORS": (
+        "claude_statusline.platforms.files",
+        "_WINDOWS_TRANSIENT_ERRORS",
+    ),
+    "_acquire_thread_lock": (
+        "claude_statusline.platforms.files",
+        "_acquire_thread_lock",
+    ),
+    "_is_transient_windows_error": (
+        "claude_statusline.platforms.files",
+        "_is_transient_windows_error",
+    ),
+    "_linux_boot_id": ("claude_statusline.platforms.clocks", "_linux_boot_id"),
+    "_linux_process_start_token": (
+        "claude_statusline.platforms.processes",
+        "_linux_process_start_token",
+    ),
+    "_macos_boot_clock": ("claude_statusline.platforms.clocks", "_macos_boot_clock"),
+    "_macos_clock_api": ("claude_statusline.platforms.clocks", "_macos_clock_api"),
+    "_macos_process_start_token": (
+        "claude_statusline.platforms.processes",
+        "_macos_process_start_token",
+    ),
+    "_release_thread_lock": (
+        "claude_statusline.platforms.files",
+        "_release_thread_lock",
+    ),
+    "_retry_windows_file_operation": (
+        "claude_statusline.platforms.files",
+        "_retry_windows_file_operation",
+    ),
+    "_set_private_mode": ("claude_statusline.platforms.files", "_set_private_mode"),
+    "_sync_parent_directory": (
+        "claude_statusline.platforms.files",
+        "_sync_parent_directory",
+    ),
+    "_windows_process_creation_filetime": (
+        "claude_statusline.platforms.processes",
+        "_windows_process_creation_filetime",
+    ),
+    "_windows_uptime_ns": ("claude_statusline.platforms.clocks", "_windows_uptime_ns"),
+    "atomic_write_bytes": ("claude_statusline.platforms.files", "atomic_write_bytes"),
+    "contextmanager": ("claude_statusline.platforms.files", "contextmanager"),
+    "durable_unlink": ("claude_statusline.platforms.files", "durable_unlink"),
+    "errno": ("claude_statusline.platforms.files", "errno"),
+    "exclusive_file_lock": ("claude_statusline.platforms.files", "exclusive_file_lock"),
+    "is_link_or_reparse": ("claude_statusline.platforms.files", "is_link_or_reparse"),
+    "is_linux": ("claude_statusline.platforms.environment", "is_linux"),
+    "is_macos": ("claude_statusline.platforms.environment", "is_macos"),
+    "is_supported_platform": (
+        "claude_statusline.platforms.environment",
+        "is_supported_platform",
+    ),
+    "is_windows": ("claude_statusline.platforms.environment", "is_windows"),
+    "is_wsl": ("claude_statusline.platforms.environment", "is_wsl"),
+    "lru_cache": ("claude_statusline.platforms.clocks", "lru_cache"),
+    "new_console_creation_flags": (
+        "claude_statusline.platforms.environment",
+        "new_console_creation_flags",
+    ),
+    "no_window_creation_flags": (
+        "claude_statusline.platforms.environment",
+        "no_window_creation_flags",
+    ),
+    "now_clocks": ("claude_statusline.platforms.clocks", "now_clocks"),
+    "os": ("claude_statusline.platforms.files", "os"),
+    "platform": ("claude_statusline.platforms.environment", "platform"),
+    "private_mode_matches": (
+        "claude_statusline.platforms.files",
+        "private_mode_matches",
+    ),
+    "process_start_token": (
+        "claude_statusline.platforms.processes",
+        "process_start_token",
+    ),
+    "stat": ("claude_statusline.platforms.files", "stat"),
+    "subprocess": ("claude_statusline.platforms.processes", "subprocess"),
+    "sys": ("claude_statusline.platforms.environment", "sys"),
+    "tempfile": ("claude_statusline.platforms.files", "tempfile"),
+    "threading": ("claude_statusline.platforms.files", "threading"),
+    "time": ("claude_statusline.platforms.clocks", "time"),
+    "uses_posix_files": ("claude_statusline.platforms.environment", "uses_posix_files"),
+}
+
+_MODULES = {}
+
+
+def __getattr__(name):
+    if name in _MODULES:
+        return import_module(_MODULES[name])
+    try:
+        module, attribute = _EXPORTS[name]
+    except KeyError:
+        raise AttributeError(name) from None
+    return getattr(import_module(module), attribute)
+
+
+def __dir__():
+    return sorted(set(globals()) | set(_EXPORTS))

claude_statusline/_version.py

@@ -0,0 +1 @@
+__version__ = "1.7.4"

claude_statusline/cli.py

@@ -0,0 +1,296 @@
+"""Command-line entry point for claude-code-statusline."""
+
+from __future__ import annotations
+
+import sys
+
+from . import _platform
+from ._version import __version__
+
+
+def _common_config_argument(parser) -> None:
+    parser.add_argument(
+        "--config-dir",
+        metavar="PATH",
+        help="Claude configuration directory (default: CLAUDE_CONFIG_DIR or ~/.claude)",
+    )
+
+
+def build_parser():
+    import argparse
+
+    from . import config_commands
+
+    parser = argparse.ArgumentParser(
+        prog="claude-statusline",
+        description="Packaged Claude Code status line for Linux, Windows and macOS.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("render", help="render status line JSON received on stdin")
+    subparsers.add_parser(
+        "render-subagents", help="render subagent status line tasks as NDJSON"
+    )
+    subparsers.add_parser(
+        "hook", help="record a Claude lifecycle hook received on stdin"
+    )
+    subparsers.add_parser(
+        "slash-hook", help="handle claude-statusline slash command hooks"
+    )
+    config_commands.add_config_parser(subparsers)
+    ui_parser = subparsers.add_parser(
+        "ui", help="serve one internal JSON configuration request"
+    )
+    _common_config_argument(ui_parser)
+    runtime_parser = subparsers.add_parser(
+        "runtime", help="serve one independent live-observation JSON request"
+    )
+    _common_config_argument(runtime_parser)
+
+    configure_parser = subparsers.add_parser(
+        "configure", help="open the interactive status line configuration editor"
+    )
+    _common_config_argument(configure_parser)
+
+    install_parser = subparsers.add_parser(
+        "install", help="configure Claude Code to use this status line"
+    )
+    _common_config_argument(install_parser)
+    install_parser.add_argument(
+        "--dry-run", action="store_true", help="report whether settings would change"
+    )
+    install_parser.add_argument(
+        "--force",
+        action="store_true",
+        help=(
+            "replace conflicting statusLine and subagentStatusLine settings, "
+            "or unrelated /statusline-config and /statusline-configure skills"
+        ),
+    )
+    experimental_group = install_parser.add_mutually_exclusive_group()
+    experimental_group.add_argument(
+        "--experimental-slash-tui",
+        dest="experimental_slash_tui",
+        action="store_true",
+        default=None,
+        help="enable external /statusline-configure (stable default; suspend on unsupported hosts)",
+    )
+    experimental_group.add_argument(
+        "--no-experimental-slash-tui",
+        dest="experimental_slash_tui",
+        action="store_false",
+        help="persistently disable the external /statusline-configure entry",
+    )
+    native_group = install_parser.add_mutually_exclusive_group()
+    native_group.add_argument(
+        "--native-editor",
+        dest="native_editor",
+        action="store_true",
+        default=None,
+        help="enable the in-session Client TUI (stable default; requires Claude Code 2.1.287+)",
+    )
+    native_group.add_argument(
+        "--no-native-editor",
+        dest="native_editor",
+        action="store_false",
+        help="persistently disable and remove owned native editor integration",
+    )
+    runtime_group = install_parser.add_mutually_exclusive_group()
+    runtime_group.add_argument(
+        "--live-metrics",
+        dest="live_metrics",
+        action="store_true",
+        default=None,
+        help="enable independent runtime collection (opt-in; Claude Code 2.1.289+)",
+    )
+    runtime_group.add_argument(
+        "--no-live-metrics",
+        dest="live_metrics",
+        action="store_false",
+        help="persistently disable independent runtime collection",
+    )
+
+    timing_group = install_parser.add_mutually_exclusive_group()
+    timing_group.add_argument("--native-timing", action="store_true", default=None,
+                              help="enable native task timing (default on compatible hosts)")
+    timing_group.add_argument("--no-native-timing", dest="native_timing", action="store_false",
+                              help="disable native timing while retaining hook/transcript timing")
+
+    uninstall_parser = subparsers.add_parser(
+        "uninstall", help="remove only this tool's Claude Code configuration"
+    )
+    _common_config_argument(uninstall_parser)
+    uninstall_parser.add_argument(
+        "--dry-run", action="store_true", help="report whether settings would change"
+    )
+
+    doctor_parser = subparsers.add_parser(
+        "doctor", help="diagnose the installation without changing files"
+    )
+    _common_config_argument(doctor_parser)
+    return parser
+
+
+def _print_change(result, dry_run: bool) -> None:
+    if result.native_state is not None:
+        print(f"native editor: {result.native_state}")
+    for message in result.messages:
+        print(message)
+    if dry_run:
+        state = "would change" if result.changed else "already correct"
+        print(f"{result.action}: {state}: {result.settings_path}")
+        for path in result.changed_paths:
+            print(f"artifact: {path}")
+        return
+    state = "updated" if result.changed else "already correct"
+    print(f"{result.action}: {state}: {result.settings_path}")
+    for path in result.changed_paths:
+        print(f"artifact: {path}")
+    if result.backup_dir is not None:
+        print(f"backup: {result.backup_dir}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    # Runtime hooks and rendering run frequently. Keep their startup paths free
+    # of argparse and installer imports used only by administrative commands.
+    if arguments == ["render"]:
+        from . import statusline
+
+        statusline.main()
+        return 0
+    if arguments == ["render-subagents"]:
+        from . import subagent_statusline
+
+        subagent_statusline.main()
+        return 0
+    if arguments == ["hook"]:
+        from . import turn_state
+
+        turn_state.main()
+        return 0
+    if arguments == ["slash-hook"]:
+        from . import slash_hook
+
+        slash_hook.main()
+        return 0
+
+    from . import config_commands, installer
+
+    parser = build_parser()
+    args = parser.parse_args(arguments)
+    if args.command == "ui":
+        from claude_statusline.ui import protocol
+
+        return protocol.main(args)
+    if args.command == "runtime":
+        from claude_statusline.runtime.live import protocol
+
+        return protocol.main(args)
+
+    if args.command == "render":
+        from . import statusline
+
+        statusline.main()
+        return 0
+    if args.command == "render-subagents":
+        from . import subagent_statusline
+
+        subagent_statusline.main()
+        return 0
+    if args.command == "hook":
+        from . import turn_state
+
+        turn_state.main()
+        return 0
+    if args.command == "slash-hook":
+        from . import slash_hook
+
+        slash_hook.main()
+        return 0
+
+    if args.command == "configure" and (
+        not sys.stdin.isatty() or not sys.stdout.isatty()
+    ):
+        print(
+            "error: configure requires both stdin and stdout to be terminals",
+            file=sys.stderr,
+        )
+        return 2
+
+    config_dir = installer.resolve_config_dir(args.config_dir)
+    try:
+        from pathlib import Path
+
+        entry = Path(sys.argv[0])
+        executable = installer.resolve_cli_executable(
+            entry.resolve()
+            if entry.name.casefold() in {"claude-statusline", "claude-statusline.exe"}
+            else None
+        )
+    except installer.ConfigurationError as exc:
+        if args.command == "doctor":
+            executable = None
+        else:
+            print(f"error: {exc}", file=sys.stderr)
+            return 2
+
+    try:
+        if args.command == "install":
+            if not _platform.is_supported_platform():
+                raise installer.ConfigurationError(
+                    "supported platforms are Linux/WSL, Windows and macOS 14+"
+                )
+            result = installer.install_configuration(
+                config_dir,
+                executable,
+                dry_run=args.dry_run,
+                force=args.force,
+                experimental_slash_tui=args.experimental_slash_tui,
+                native_editor=args.native_editor,
+                live_metrics=args.live_metrics,
+                native_timing=args.native_timing,
+            )
+            _print_change(result, args.dry_run)
+            return 2 if result.native_failed else 0
+        if args.command == "configure":
+            if not _platform.is_supported_platform():
+                raise installer.ConfigurationError(
+                    "supported platforms are Linux/WSL, Windows and macOS 14+"
+                )
+            # Keep curses out of render, hook, and slash-hook startup paths.
+            try:
+                from . import interactive_config
+            except ImportError as exc:
+                raise installer.ConfigurationError(
+                    f"configure requires an available curses backend: {exc}"
+                ) from exc
+
+            return interactive_config.run(config_dir, executable)
+        if args.command == "uninstall":
+            result = installer.uninstall_configuration(
+                config_dir, executable, dry_run=args.dry_run
+            )
+            _print_change(result, args.dry_run)
+            return 2 if result.native_failed else 0
+        if args.command == "doctor":
+            diagnostics = installer.collect_diagnostics(config_dir, executable)
+            for item in diagnostics:
+                print(f"[{item.level}] {item.message}")
+            return 1 if any(item.level == "ERROR" for item in diagnostics) else 0
+        if args.command == "config":
+            print(
+                config_commands.execute_config_namespace(args, config_dir, executable)
+            )
+            return 0
+    except (installer.ConfigurationError, config_commands.ConfigCommandError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    parser.error(f"unknown command: {args.command}")
+    return 2

claude_statusline/config/__init__.py

@@ -0,0 +1 @@
+"""config subsystem."""

claude_statusline/config/advanced.py

@@ -0,0 +1,74 @@
+"""Pure mutations used by CLI and interactive draft editors."""
+
+from dataclasses import replace
+
+from claude_statusline.config import catalog, display, formatting
+
+
+def edit_item(config, scope, item, option, value):
+    if scope == "main":
+        item = catalog.canonical_item(item)
+    definitions = (
+        display.ITEM_CATALOG if scope == "main" else display.SUBAGENT_ITEM_CATALOG
+    )
+    if scope not in ("main", "subagent") or item not in definitions:
+        raise display.DisplayConfigError("unknown scoped item")
+    current = config.item_options if scope == "main" else config.subagents.item_options
+    options = dict(current)
+    data = options.get(item, formatting.ItemOptions()).to_dict()
+    key = option.replace("-", "_")
+    if key in formatting.FORMAT_CHOICES:
+        if value == "inherit":
+            data["formatting"].pop(key, None)
+        else:
+            data["formatting"][key] = value
+    elif key in ("label", "icon", "priority", "max_width"):
+        if key in ("priority", "max_width"):
+            try:
+                value = None if value in (None, "none") else int(value)
+            except (ValueError, TypeError) as exc:
+                raise display.DisplayConfigError(
+                    "width/priority must be an integer or none"
+                ) from exc
+        elif value == "inherit":
+            value = None
+        data[key] = value
+    else:
+        raise display.DisplayConfigError("unknown item option")
+    try:
+        options[item] = formatting.ItemOptions.parse(data)
+    except ValueError as exc:
+        raise display.DisplayConfigError(str(exc)) from exc
+    return (
+        config.with_updates(item_options=options)
+        if scope == "main"
+        else config.with_updates(
+            subagents=config.subagents.with_updates(item_options=options)
+        )
+    )
+
+
+def edit_layout(config, mode, rows=None):
+    draft = {
+        "mode": mode,
+        "rows": rows
+        or ([list(config.items)] if mode == "explicit" and config.items else []),
+    }
+    data = config.to_dict()
+    data["layout"] = draft
+    return display.validate_display_config(data)
+
+
+def edit_subagent(config, field, value):
+    if field == "hide_completed":
+        if value not in ("on", "off", True, False):
+            raise display.DisplayConfigError("hide-completed must be on/off")
+        value = value in ("on", True)
+    elif field in ("row_limit", "task_max_width"):
+        try:
+            value = None if value in ("none", None) else int(value)
+        except (ValueError, TypeError) as exc:
+            raise display.DisplayConfigError(
+                "limit must be an integer or none"
+            ) from exc
+    return config.with_updates(subagents=replace(config.subagents, **{field: value}))