usage-cli 0.29.32__py3-none-any.whl

statusline_settings.py

@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import shlex
+import sys
+from pathlib import Path
+from typing import Any
+
+from setup_hook import _atomic_write_text
+
+
+def _claude_settings_path() -> Path:
+    return Path(os.path.expanduser("~/.claude/settings.json"))
+
+
+def _load_claude_settings() -> dict[str, Any]:
+    settings_path = _claude_settings_path()
+    if not settings_path.exists():
+        return {}
+    with settings_path.open(encoding="utf-8") as file:
+        settings = json.load(file)
+    if not isinstance(settings, dict):
+        raise ValueError(f"{settings_path} must be a JSON object")
+    return settings
+
+
+def _save_claude_settings(settings: dict[str, Any]) -> None:
+    settings_path = _claude_settings_path()
+    trailing_newline = True
+    with contextlib.suppress(OSError):
+        trailing_newline = settings_path.read_bytes().endswith(b"\n")
+    content = json.dumps(settings, indent=2, ensure_ascii=False)
+    if trailing_newline:
+        content += "\n"
+    _atomic_write_text(settings_path, content)
+
+
+def _statusline_command_target_exists(statusline: object) -> bool:
+    if not isinstance(statusline, dict):
+        return True
+    command = statusline.get("command")
+    if not isinstance(command, str):
+        return True
+    try:
+        parts = shlex.split(command)
+    except ValueError:
+        return True
+    for part in parts:
+        if "statusline" not in part or not part.endswith(".py"):
+            continue
+        return Path(os.path.expanduser(part)).exists()
+    return True
+
+
+def _set_forwarder_mode_prompt_dismissed() -> None:
+    import setup_hook
+
+    settings = setup_hook._load_settings()
+    usage_settings = settings.get(setup_hook.BACKUP_KEY)
+    if not isinstance(usage_settings, dict):
+        usage_settings = {}
+        settings[setup_hook.BACKUP_KEY] = usage_settings
+    usage_settings["forwarderModePromptDismissed"] = True
+    setup_hook._save_settings(settings)
+
+
+def _sync_agy_statusline(enable: bool) -> None:
+    """Mirror the switch onto Antigravity's status line when its CLI is installed.
+
+    Antigravity is a side effect of the one switch the panel shows, so a missing
+    or unwritable ~/.gemini config must never stop Claude's own status line from
+    being toggled.
+    """
+    if sys.platform not in {"darwin", "win32"}:
+        return
+    import setup_hook
+
+    with contextlib.suppress(Exception):
+        if enable:
+            setup_hook._setup_agy()
+        else:
+            setup_hook._unsetup_agy()
+
+
+def _disable_statusline_settings() -> int:
+    _sync_agy_statusline(False)
+    settings = _load_claude_settings()
+    if "statusLine" not in settings:
+        return 0
+    usage_settings = settings.setdefault("usage", {})
+    if not isinstance(usage_settings, dict):
+        usage_settings = {}
+        settings["usage"] = usage_settings
+    usage_settings["previousStatusLine"] = settings["statusLine"]
+    del settings["statusLine"]
+    _save_claude_settings(settings)
+    return 0
+
+
+def _enable_statusline_settings() -> int:
+    _sync_agy_statusline(True)
+    settings = _load_claude_settings()
+    if "statusLine" in settings:
+        return 0
+    raw_usage_settings = settings.get("usage")
+    usage_settings = raw_usage_settings if isinstance(raw_usage_settings, dict) else None
+    previous = usage_settings.get("previousStatusLine") if usage_settings is not None else None
+    if previous:
+        assert usage_settings is not None
+        if not _statusline_command_target_exists(previous):
+            del usage_settings["previousStatusLine"]
+            if not usage_settings:
+                del settings["usage"]
+            _save_claude_settings(settings)
+            import setup_hook
+
+            return setup_hook.setup()
+        settings["statusLine"] = previous
+        del usage_settings["previousStatusLine"]
+        if not usage_settings:
+            del settings["usage"]
+        _save_claude_settings(settings)
+        return 0
+
+    import setup_hook
+
+    exit_code = setup_hook.setup()
+    if exit_code != 0 and setup_hook.is_agy_setup():
+        return 0
+    return exit_code
+
+
+def _toggle_statusline_settings() -> tuple[str, int]:
+    if _statusline_enabled():
+        return "uninstall", _disable_statusline_settings()
+    return "install", _enable_statusline_settings()
+
+
+def _statusline_enabled() -> bool:
+    try:
+        settings = _load_claude_settings()
+    except (OSError, ValueError, json.JSONDecodeError):
+        return False
+    if "statusLine" in settings:
+        return True
+    if sys.platform not in {"darwin", "win32"}:
+        return False
+    with contextlib.suppress(Exception):
+        import setup_hook
+
+        return setup_hook.is_agy_setup()
+    return False

talent_market_bridge.py

@@ -0,0 +1,243 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty
+# disclaimer.
+
+# mypy: disable-error-code="import-untyped,import-not-found,misc"
+"""Bridge to the external ``instate-cli`` executable that powers the
+"AI 人才市場" panel.
+
+The CLI is built in a separate project (``~/Developer/instate``) and bundled
+into ``vendor/instate-cli`` at .app build time. It prints one JSON object per
+invocation on stdout. Every wrapper here returns a dict and never raises, so a
+missing/broken CLI degrades to an empty-state panel instead of crashing the
+popover. Folder selection uses a native ``NSOpenPanel`` (no CLI round-trip).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+TIMEOUT_SECONDS = 10.0
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parent
+
+
+def _bundled_cli_path() -> Path | None:
+    try:
+        from Foundation import NSBundle
+    except ImportError:
+        return None
+    bundle = NSBundle.mainBundle()
+    if bundle is None:
+        return None
+    # py2app flattens a single-file resource to Resources/<basename>, so the
+    # compiled CLI lives at Resources/instate-cli. In dev (python3 main.py) the
+    # main bundle is the Python framework and this returns None → fall back to
+    # repo vendor/instate-cli.
+    path = bundle.pathForResource_ofType_("instate-cli", "")
+    if path:
+        return Path(str(path))
+    return None
+
+
+def _cli_path() -> Path:
+    bundled = _bundled_cli_path()
+    if bundled is not None:
+        return bundled
+    vendor = "vendor"
+    name = "instate-cli"
+    return _repo_root() / vendor / name
+
+
+def _run(args: list[str]) -> dict[str, Any]:
+    cli = _cli_path()
+    if not cli.exists():
+        return {"ok": False, "status": "missing", "error": "instate-cli not installed"}
+    try:
+        proc = subprocess.run(  # noqa: S603 — fixed local binary, args are constants/IDs
+            [str(cli), *args],
+            capture_output=True,
+            text=True,
+            timeout=TIMEOUT_SECONDS,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except subprocess.TimeoutExpired:
+        return {"ok": False, "status": "timeout", "error": "instate-cli timed out"}
+    except Exception as exc:
+        # Any failure to spawn/read (OSError, decode hiccups, ...) degrades to
+        # an error dict — the panel shows its empty state instead of crashing.
+        return {"ok": False, "status": "error", "error": str(exc)}
+    if proc.returncode != 0:
+        return {
+            "ok": False,
+            "status": "error",
+            "error": (proc.stderr or "").strip() or f"instate-cli exited {proc.returncode}",
+        }
+    try:
+        parsed = json.loads(proc.stdout)
+    except json.JSONDecodeError:
+        return {
+            "ok": False,
+            "status": "error",
+            "error": "instate-cli returned non-JSON",
+            "stdout": proc.stdout,
+        }
+    if not isinstance(parsed, dict):
+        return {"ok": False, "status": "error", "error": "instate-cli returned non-object"}
+    return parsed
+
+
+def list_state(lang: str | None = None) -> dict[str, Any]:
+    args = ["list-state"]
+    if lang:
+        args.append(lang)
+    return _run(args)
+
+
+def list_personas(lang: str | None = None) -> list[dict[str, str]]:
+    """Return every available role as a flat, discussion-friendly record."""
+    try:
+        state = list_state(lang)
+    except Exception:
+        return []
+    packs = state.get("packs")
+    if not isinstance(packs, list):
+        return []
+    personas: list[dict[str, str]] = []
+    for pack in packs:
+        if not isinstance(pack, dict):
+            continue
+        pack_id = pack.get("id")
+        pack_name = pack.get("name")
+        if not isinstance(pack_id, str) or not isinstance(pack_name, str):
+            pack_id = ""
+            pack_name = ""
+        roles = pack.get("roles")
+        if not isinstance(roles, list):
+            continue
+        for role in roles:
+            if not isinstance(role, dict):
+                continue
+            role_id = role.get("id")
+            name = role.get("name")
+            persona_name = role.get("personaName")
+            description = role.get("description")
+            system_prompt = role.get("systemPrompt")
+            if (
+                not isinstance(role_id, str)
+                or not isinstance(name, str)
+                or not isinstance(persona_name, str)
+                or not isinstance(description, str)
+                or not isinstance(system_prompt, str)
+            ):
+                continue
+            personas.append(
+                {
+                    "id": role_id,
+                    "name": name,
+                    "persona_name": persona_name,
+                    "description": description,
+                    "system_prompt": system_prompt,
+                    "pack_id": pack_id,
+                    "pack_name": pack_name,
+                }
+            )
+    return personas
+
+
+def install_role(role_id: str) -> dict[str, Any]:
+    return _run(["install", role_id])
+
+
+def launch_role(role_id: str, task_prompt: str | None = None) -> dict[str, Any]:
+    args = ["launch", role_id]
+    if task_prompt:
+        args.append(task_prompt)
+    return _run(args)
+
+
+def restore_role(role_id: str) -> dict[str, Any]:
+    return _run(["restore", role_id])
+
+
+def ignore_drift(role_id: str) -> dict[str, Any]:
+    return _run(["ignore-drift", role_id])
+
+
+def set_folder(role_id: str, path: str) -> dict[str, Any]:
+    return _run(["set-folder", role_id, path])
+
+
+def pick_folder() -> str | None:
+    """Open a native folder picker; return the chosen path or ``None``.
+
+    The popover's content window sits at ``NSNormalWindowLevel`` and usage runs
+    as an accessory app (no Dock icon). A bare ``runModal`` opens the panel at
+    the same level, so it lands behind the still-open popover and never takes
+    focus — the user clicks "選擇資料夾" and nothing visible happens. Two nudges
+    fix it: activate the app so the panel can become key, and raise the panel
+    one notch above ``NSPopUpMenuWindowLevel`` so it clears the popover.
+    """
+    try:
+        from AppKit import NSApp, NSOpenPanel, NSPopUpMenuWindowLevel
+    except ImportError:
+        return None
+    NSApp.activateIgnoringOtherApps_(True)
+    panel = NSOpenPanel.openPanel()
+    panel.setCanChooseFiles_(False)
+    panel.setCanChooseDirectories_(True)
+    panel.setAllowsMultipleSelection_(False)
+    panel.setResolvesAliases_(True)
+    panel.setLevel_(NSPopUpMenuWindowLevel + 1)
+    if panel.runModal() != 1:  # NSModalResponseOK
+        return None
+    urls = panel.URLs()
+    if urls is None or len(urls) == 0:
+        return None
+    url = urls[0]
+    if url is None:
+        return None
+    path = url.path()
+    return str(path) if path else None
+
+
+def pick_image_file() -> str | None:
+    """Open a native image picker; return the chosen path or ``None``.
+
+    Shares the activation/level fixups of :func:`pick_folder` so the panel lands
+    in front of the discussion window instead of behind it.
+    """
+    try:
+        from AppKit import NSApp, NSOpenPanel, NSPopUpMenuWindowLevel
+    except ImportError:
+        return None
+    NSApp.activateIgnoringOtherApps_(True)
+    panel = NSOpenPanel.openPanel()
+    panel.setCanChooseFiles_(True)
+    panel.setCanChooseDirectories_(False)
+    panel.setAllowsMultipleSelection_(False)
+    panel.setResolvesAliases_(True)
+    panel.setAllowedFileTypes_(["png", "jpg", "jpeg", "gif", "webp"])
+    panel.setLevel_(NSPopUpMenuWindowLevel + 1)
+    if panel.runModal() != 1:  # NSModalResponseOK
+        return None
+    urls = panel.URLs()
+    if urls is None or len(urls) == 0:
+        return None
+    url = urls[0]
+    if url is None:
+        return None
+    path = url.path()
+    return str(path) if path else None

time_utils.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+
+def parse_optional_iso8601_utc(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return _coerce_utc(parsed)
+
+
+def parse_iso8601_utc_or_raise(value: str) -> datetime:
+    parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    return _coerce_utc(parsed)
+
+
+def _coerce_utc(value: datetime) -> datetime:
+    if value.tzinfo is None:
+        return value.replace(tzinfo=UTC)
+    return value.astimezone(UTC)