tweek 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

tweek/cli_helpers.py

@@ -7,9 +7,14 @@ Provides colored status messages, health banners, command example formatting,
 and progress spinners.
 """
 
+import json
+import shutil
 from contextlib import contextmanager
+from pathlib import Path
 from typing import List, Tuple
 
+import click
+
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
@@ -191,3 +196,314 @@ def print_doctor_json(checks: "List") -> None:
     }
 
     console.print_json(json.dumps(output, indent=2))
+
+
+# ---------------------------------------------------------------------------
+# Cross-module constants and helpers
+# ---------------------------------------------------------------------------
+
+TWEEK_BANNER = """
+ ████████╗██╗    ██╗███████╗███████╗██╗  ██╗
+ ╚══██╔══╝██║    ██║██╔════╝██╔════╝██║ ██╔╝
+    ██║   ██║ █╗ ██║█████╗  █████╗  █████╔╝
+    ██║   ██║███╗██║██╔══╝  ██╔══╝  ██╔═██╗
+    ██║   ╚███╔███╔╝███████╗███████╗██║  ██╗
+    ╚═╝    ╚══╝╚══╝ ╚══════╝╚══════╝╚═╝  ╚═╝
+
+  GAH! Security for AI agents
+  "Because paranoia is a feature, not a bug"
+"""
+
+
+def _has_tweek_hooks(settings: dict) -> bool:
+    """Check if a settings dict contains Tweek hooks."""
+    hooks = settings.get("hooks", {})
+    for hook_type in ("PreToolUse", "PostToolUse"):
+        for hook_config in hooks.get(hook_type, []):
+            for hook in hook_config.get("hooks", []):
+                if "tweek" in hook.get("command", "").lower():
+                    return True
+    return False
+
+
+def _has_tweek_at(target: Path) -> bool:
+    """Check if Tweek is installed at a .claude/ target path."""
+    import json
+
+    if (target / "skills" / "tweek").exists():
+        return True
+    if (target / "settings.json.tweek-backup").exists():
+        return True
+    settings_file = target / "settings.json"
+    if settings_file.exists():
+        try:
+            with open(settings_file) as f:
+                settings = json.load(f)
+            if _has_tweek_hooks(settings):
+                return True
+        except (json.JSONDecodeError, IOError):
+            pass
+    return False
+
+
+def _detect_all_tools():
+    """Detect all supported AI tools and their protection status.
+
+    Returns list of (tool_id, label, installed, protected, detail) tuples.
+    """
+    import shutil
+    import json
+
+    tools = []
+
+    # Claude Code
+    claude_installed = shutil.which("claude") is not None
+    claude_protected = _has_tweek_at(Path("~/.claude").expanduser()) if claude_installed else False
+    tools.append((
+        "claude-code", "Claude Code", claude_installed, claude_protected,
+        "Hooks in ~/.claude/settings.json" if claude_protected else "",
+    ))
+
+    # OpenClaw
+    oc_installed = False
+    oc_protected = False
+    oc_detail = ""
+    try:
+        from tweek.integrations.openclaw import detect_openclaw_installation
+        openclaw = detect_openclaw_installation()
+        oc_installed = openclaw.get("installed", False)
+        if oc_installed:
+            oc_protected = openclaw.get("tweek_configured", False)
+            oc_detail = f"Gateway port {openclaw.get('gateway_port', '?')}"
+    except Exception:
+        pass
+    tools.append(("openclaw", "OpenClaw", oc_installed, oc_protected, oc_detail))
+
+    # MCP clients
+    mcp_configs = [
+        ("claude-desktop", "Claude Desktop",
+         Path("~/Library/Application Support/Claude/claude_desktop_config.json").expanduser()),
+        ("chatgpt", "ChatGPT Desktop",
+         Path("~/Library/Application Support/com.openai.chat/developer_settings.json").expanduser()),
+        ("gemini", "Gemini CLI",
+         Path("~/.gemini/settings.json").expanduser()),
+    ]
+    for tool_id, label, config_path in mcp_configs:
+        installed = config_path.exists()
+        protected = False
+        if installed:
+            try:
+                with open(config_path) as f:
+                    data = json.load(f)
+                mcp_servers = data.get("mcpServers", {})
+                protected = "tweek-security" in mcp_servers or "tweek" in mcp_servers
+            except Exception:
+                pass
+        detail = str(config_path) if protected else ""
+        tools.append((tool_id, label, installed, protected, detail))
+
+    return tools
+
+
+# ---------------------------------------------------------------------------
+# TieredGroup — progressive disclosure for CLI help
+# ---------------------------------------------------------------------------
+
+# Command tiers: shown in order in default --help output.
+# Commands not listed here go into "All other commands" (compressed).
+COMMAND_TIERS = {
+    "Getting Started": [
+        "protect",
+        "status",
+        "doctor",
+        "update",
+        "upgrade",
+        "configure",
+    ],
+    "Security & Trust": [
+        "trust",
+        "untrust",
+        "config",
+        "audit",
+    ],
+}
+
+# All commands that appear in an explicit tier above
+_TIERED_COMMANDS = {cmd for cmds in COMMAND_TIERS.values() for cmd in cmds}
+
+
+class TieredGroup(click.Group):
+    """A Click Group that displays commands in tiered categories.
+
+    Default ``--help`` shows core commands with full descriptions and
+    compresses remaining commands into a single line.  Pass ``--help-all``
+    to see every command with its description, grouped by category.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.params.append(
+            click.Option(
+                ["--help-all"],
+                is_flag=True,
+                expose_value=False,
+                is_eager=True,
+                callback=self._show_help_all,
+                help="Show all commands with full descriptions.",
+            )
+        )
+
+    def _show_help_all(self, ctx, _param, value):
+        if not value:
+            return
+        # Build the full categorised help text and print it
+        formatter = ctx.make_formatter()
+        self.format_usage(ctx, formatter)
+        self.format_help_text(ctx, formatter)
+        self._format_all_commands(ctx, formatter)
+        formatter.write("\n")
+        click.echo(formatter.getvalue().rstrip("\n"))
+        ctx.exit(0)
+
+    # -- default help (tiered) ------------------------------------------------
+
+    def format_commands(self, ctx, formatter):
+        """Override: render tiered command list instead of flat alphabetical."""
+        commands = self._sorted_commands(ctx)
+        if not commands:
+            return
+
+        cmd_map = {name: cmd for name, cmd in commands}
+        max_len = max(len(name) for name, _ in commands)
+
+        # Tier 1+2: explicit categories with full descriptions
+        for tier_name, tier_cmds in COMMAND_TIERS.items():
+            rows = []
+            for name in tier_cmds:
+                cmd = cmd_map.get(name)
+                if cmd is None:
+                    continue
+                help_text = cmd.get_short_help_str(limit=150)
+                rows.append((name, help_text))
+            if rows:
+                with formatter.section(tier_name):
+                    formatter.write_dl(rows)
+
+        # Remaining: compressed into a single line
+        other_names = [name for name, _ in commands if name not in _TIERED_COMMANDS]
+        if other_names:
+            with formatter.section("All other commands"):
+                # Wrap the names at ~60 chars per line for readability
+                lines = _wrap_names(other_names, width=60)
+                for line in lines:
+                    formatter.write(f"  {line}\n")
+
+            formatter.write(
+                "\n  Run 'tweek <command> --help' for details on any command.\n"
+                "  Run 'tweek --help-all' for the full command list.\n"
+            )
+
+    # -- --help-all output (full categorised) ---------------------------------
+
+    _FULL_TIERS = {
+        **COMMAND_TIERS,
+        "Diagnostics": [
+            "logs",
+            "feedback",
+            "override",
+        ],
+        "Infrastructure": [
+            "vault",
+            "proxy",
+            "mcp",
+            "plugins",
+            "skills",
+            "dry-run",
+            "memory",
+            "model",
+        ],
+        "Lifecycle": [
+            "install",
+            "uninstall",
+            "unprotect",
+            "license",
+        ],
+    }
+
+    def _format_all_commands(self, ctx, formatter):
+        """Render every command grouped into categories."""
+        commands = self._sorted_commands(ctx)
+        if not commands:
+            return
+        cmd_map = {name: cmd for name, cmd in commands}
+        shown = set()
+
+        for tier_name, tier_cmds in self._FULL_TIERS.items():
+            rows = []
+            for name in tier_cmds:
+                cmd = cmd_map.get(name)
+                if cmd is None:
+                    continue
+                rows.append((name, cmd.get_short_help_str(limit=150)))
+                shown.add(name)
+            if rows:
+                with formatter.section(tier_name):
+                    formatter.write_dl(rows)
+
+        # Catch-all for anything not in _FULL_TIERS (future-proofing)
+        leftover = [(n, c.get_short_help_str(limit=150))
+                     for n, c in commands if n not in shown]
+        if leftover:
+            with formatter.section("Other"):
+                formatter.write_dl(leftover)
+
+    # -- helpers --------------------------------------------------------------
+
+    def _sorted_commands(self, ctx):
+        """Return (name, command) pairs sorted alphabetically, skipping hidden."""
+        source = self.list_commands(ctx)
+        pairs = []
+        for name in source:
+            cmd = self.get_command(ctx, name)
+            if cmd is None or cmd.hidden:
+                continue
+            pairs.append((name, cmd))
+        return pairs
+
+
+def _wrap_names(names, width=60):
+    """Wrap a list of command names into lines of roughly *width* chars."""
+    lines = []
+    current = ""
+    for name in names:
+        candidate = f"{current}, {name}" if current else name
+        if len(candidate) > width and current:
+            lines.append(current)
+            current = name
+        else:
+            current = candidate
+    if current:
+        lines.append(current)
+    return lines
+
+
+def _load_overrides_yaml() -> tuple:
+    """Load ~/.tweek/overrides.yaml. Returns (data_dict, file_path)."""
+    import yaml
+
+    overrides_path = Path("~/.tweek/overrides.yaml").expanduser()
+    if overrides_path.exists():
+        with open(overrides_path) as f:
+            data = yaml.safe_load(f) or {}
+    else:
+        data = {}
+    return data, overrides_path
+
+
+def _save_overrides_yaml(data: dict, overrides_path: Path):
+    """Write data to ~/.tweek/overrides.yaml."""
+    import yaml
+
+    overrides_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(overrides_path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)