thoughtleaders-cli 0.9.9__tar.gz → 0.9.11__tar.gz

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tl-cli",
-  "version": "0.9.9",
+  "version": "0.9.11",
   "description": "ThoughtLeaders CLI — query sponsorship deals, channels, brands, uploads, and intelligence from the terminal",
   "author": {
     "name": "ThoughtLeaders",

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thoughtleaders-cli
-Version: 0.9.9
+Version: 0.9.11
 Summary: ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence
 Project-URL: Homepage, https://thoughtleaders.io
 Project-URL: Repository, https://github.com/ThoughtLeaders-io/thoughtleaders-cli

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thoughtleaders-cli"
-version = "0.9.9"
+version = "0.9.11"
 description = "ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence"
 readme = "README.md"
 license = "MIT"

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/skills/tl/references/elasticsearch-schema.md

@@ -108,7 +108,8 @@ Contains a denormalized subset of the PostgreSQL channel data.
 | `media_selling_network_join_date` | date | MSN join date; non-null = MSN member (~1%) |
 | `has_outreach_email` | boolean | Has contact email (100%) |
 | `outreach_email` | text | Contact email (~45%) |
-| `social_links` | text | Flat array of the channel's profile URLs (~47%), e.g. `["https://twitter.com/…", "https://instagram.com/…", "https://discord.gg/…"]`. Source is a per-platform map plus a catch-all `_other` map for unrecognized platforms; in ES all of it is flattened into this one URL array (the `_other` URLs are folded in, the platform names are dropped). Occasional stray entries (bare emails, nested arrays) exist. |
+| `social_links` | text | Flat array of the channel's known profile links as **canonical keys** — lowercase `host/path` with no scheme, no `www.`, no query string, and `x.com` spelled as `twitter.com`, e.g. `["twitter.com/mrbeast", "instagram.com/mrbeast", "linktr.ee/foo"]` (~47%, growing). Sourced from the `all_social_links` accumulator (About-page scrapes plus web-search discoveries); platform names are dropped, e-mails never appear. |
+| `social_links.canonical` | text | Subfield of the above with a path-segment analyzer: one token per URL segment, subdomain-insensitive host. `{"match_phrase": {"social_links.canonical": "twitch.tv/ludwig"}}` is the precise way to ask "which channels carry exactly this profile link" — it matches `m.twitch.tv/ludwig` and deep paths under the profile, but never a channel that merely mentions the same words in different links. Prefer it over matching the parent field when the query is a `domain/handle` pair. |
 | `male_share` | byte | Male audience % — only ~1.6% of channel docs have demographic data |
 | `usa_share` | byte | US audience % — same ~1.6% coverage |
 | `device` | object | Audience device demographics where known: `device.primary` (most common device) and `device.share` (per-device % map). Very sparse (~0.2%). |

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/src/tl_cli/__init__.py

@@ -1,3 +1,3 @@
 """ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence."""
 
-__version__ = "0.9.9"
+__version__ = "0.9.11"

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/src/tl_cli/commands/setup.py

@@ -160,14 +160,69 @@ def _run_claude(args: list[str], claude_bin: str) -> tuple[bool, str]:
         return False, str(e)
 
 
+def _installed_plugin_version() -> str | None:
+    """Version of the plugin Claude Code actually has on disk, or None.
+
+    Reads Claude Code's own install record rather than trusting the stamp
+    written at setup time: `plugin install` is a no-op once the plugin is
+    present, so a stamp saying "whatever the CLI version was when setup last
+    ran" can name a version that was never installed. Returns None when the
+    record is missing or unreadable — callers treat that as "unknown", never
+    as "outdated", so a change to Claude Code's bookkeeping cannot turn into
+    a false warning for every user at once.
+    """
+    try:
+        record = json.loads((CLAUDE_PLUGINS_DIR / "installed_plugins.json").read_text(encoding="utf-8"))
+        entries = record["plugins"][PLUGIN_KEY]
+    except (OSError, ValueError, KeyError, TypeError):
+        return None
+    if not isinstance(entries, list):
+        return None
+    # One entry per install scope; setup installs at user scope, so prefer it.
+    scoped = sorted((e for e in entries if isinstance(e, dict)), key=lambda e: e.get("scope") != "user")
+    for entry in scoped:
+        version = entry.get("version")
+        if isinstance(version, str) and version and version != "unknown":
+            return version
+    return None
+
+
 def _get_installed_plugin_version() -> str | None:
-    """Try to read the installed plugin version from the cache."""
+    """Installed plugin version: Claude Code's record, else the setup stamp.
+
+    The stamp is the fallback for installs that never reached the plugin
+    registry (the standalone-skills path), where the copied skills really are
+    the ones this CLI shipped with.
+    """
+    version = _installed_plugin_version()
+    if version:
+        return version
     version_file = CLAUDE_PLUGINS_DIR / "tl-cli" / ".version"
     if version_file.exists():
         return version_file.read_text().strip()
     return None
 
 
+def _write_version_stamp(version: str) -> None:
+    """Record which plugin version is installed, for `check_plugin_version()`."""
+    version_dir = CLAUDE_PLUGINS_DIR / "tl-cli"
+    version_dir.mkdir(parents=True, exist_ok=True)
+    (version_dir / ".version").write_text(version)
+
+
+def _update_plugin(claude_bin: str) -> tuple[bool, bool, str]:
+    """Pull the installed plugin up to the marketplace's current version.
+
+    `plugin install` exits successfully without doing anything when the
+    plugin is already installed, so this is what actually advances an
+    existing install. Returns (ok, changed, output); `changed` is False when
+    the plugin was already at the latest version.
+    """
+    ok, output = _run_claude(["plugin", "update", PLUGIN_KEY], claude_bin)
+    changed = ok and "already at the latest" not in output.lower()
+    return ok, changed, output
+
+
 def check_plugin_version() -> list[str]:
     """Check if installed plugin versions match CLI version.
 
@@ -176,11 +231,9 @@ def check_plugin_version() -> list[str]:
     warnings = []
 
     # Claude Code
-    claude_version_file = CLAUDE_PLUGINS_DIR / "tl-cli" / ".version"
-    if claude_version_file.exists():
-        installed = claude_version_file.read_text().strip()
-        if installed != __version__:
-            warnings.append(f"Claude Code plugin is outdated (v{installed} vs CLI v{__version__}). Run 'tl setup claude' to update.")
+    installed = _get_installed_plugin_version()
+    if installed and installed != __version__:
+        warnings.append(f"Claude Code plugin is outdated (v{installed} vs CLI v{__version__}). Run 'tl setup claude' to update.")
 
     # OpenCode
     opencode_version_file = OPENCODE_SKILLS_DIR / ".tl-version"
@@ -368,9 +421,9 @@ def setup_claude(
 ) -> None:
     """Install the TL CLI plugin for Claude Code.
 
-    Registers the ThoughtLeaders marketplace, installs the tl-cli plugin,
-    and adds a /tl shim command so the plugin's tl skill can be invoked
-    without the plugin namespace. Standalone skill copies in ~/.claude/skills
+    Registers the ThoughtLeaders marketplace, installs and updates the
+    tl-cli plugin, and adds a /tl shim command so the plugin's tl skill can
+    be invoked without the plugin namespace. Standalone skill copies in ~/.claude/skills
     are only installed as a fallback when the plugin can't be installed;
     unmodified copies left by earlier versions are removed.
 
@@ -445,7 +498,23 @@ def setup_claude(
             _print_manual_instructions()
             raise SystemExit(1)
 
-    # Step 3: /tl shim command + cleanup of standalone copies from older versions
+    # Step 3: Update the plugin. An install that found the plugin already
+    # present did nothing, so without this an existing install stays pinned
+    # at whatever version it was first installed at.
+    console.print("[bold]Updating plugin...[/bold]")
+    ok, changed, output = _update_plugin(claude_bin)
+    installed_version = _installed_plugin_version()
+    version_label = f"v{installed_version}" if installed_version else "version unknown"
+    if not ok:
+        console.print(f"  [yellow]![/yellow] Plugin update failed: {output}")
+        console.print(f"    Continuing with the installed plugin ({version_label}).")
+    elif changed:
+        console.print(f"  [green]✓[/green] Plugin updated to {version_label}")
+        console.print("    [yellow]Restart Claude Code to apply the new version.[/yellow]")
+    else:
+        console.print(f"  [green]✓[/green] Plugin already up to date ({version_label})")
+
+    # Step 4: /tl shim command + cleanup of standalone copies from older versions
     console.print("[bold]Installing /tl shortcut...[/bold]")
     shim = _install_command_shim()
     console.print(f"  [green]✓[/green] /tl command installed: {shim}")
@@ -456,10 +525,7 @@ def setup_claude(
         console.print(f"  [yellow]![/yellow] Kept {kept} modified standalone skill(s) in {CLAUDE_SKILLS_DIR}")
         console.print("    These differ from the plugin's versions and shadow nothing — remove manually if unwanted.")
 
-    # Write version stamp
-    version_dir = CLAUDE_PLUGINS_DIR / "tl-cli"
-    version_dir.mkdir(parents=True, exist_ok=True)
-    (version_dir / ".version").write_text(__version__)
+    _write_version_stamp(installed_version or __version__)
 
     console.print()
     console.print("[green]Setup complete![/green]")
@@ -523,6 +589,14 @@ def _setup_noninteractive(fmt: str = "json") -> None:
 
         ok, output = _run_claude(["plugin", "install", PLUGIN_KEY], claude_bin)
         result["plugin_installed"] = ok or "already" in output.lower()
+
+        # `install` is a no-op on an already-installed plugin — this is what
+        # advances it to the marketplace's current version.
+        if result["plugin_installed"]:
+            ok, changed, output = _update_plugin(claude_bin)
+            result["plugin_updated"] = changed
+            if not ok:
+                result["plugin_update_error"] = output
     else:
         result["marketplace_registered"] = False
         result["plugin_installed"] = False
@@ -541,10 +615,11 @@ def _setup_noninteractive(fmt: str = "json") -> None:
         result["command_shim_installed"] = False
         result["standalone_skills_installed"] = _install_standalone_skills(plugin_root)
 
-    # Write version stamp
-    version_dir = CLAUDE_PLUGINS_DIR / "tl-cli"
-    version_dir.mkdir(parents=True, exist_ok=True)
-    (version_dir / ".version").write_text(__version__)
+    # Stamp what is actually installed. The standalone fallback copied this
+    # CLI's own bundled skills, so there __version__ is the honest answer.
+    installed_version = _installed_plugin_version() if result["plugin_installed"] else None
+    result["plugin_version"] = installed_version
+    _write_version_stamp(installed_version or __version__)
 
     result["status"] = "ok"
     _emit_setup_result(result, fmt)

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/src/tl_cli/self_update.py

@@ -426,7 +426,11 @@ def _resync_integrations() -> None:
             subprocess.run(
                 [tl_bin, "setup", tool, "--json"],
                 capture_output=True,
-                timeout=120,
+                # The Claude Code path shells out to `claude` several times
+                # (marketplace add + update, plugin install + update), each
+                # with its own timeout — a 120s budget for the whole resync
+                # can expire mid-sequence on a slow network.
+                timeout=300,
                 check=False,
             )
         except (OSError, subprocess.TimeoutExpired):

{thoughtleaders_cli-0.9.9 → thoughtleaders_cli-0.9.11}/tests/test_setup.py

@@ -1,5 +1,6 @@
 """Tests for `tl setup` helpers."""
 
+import json
 import sys
 from pathlib import Path
 
@@ -8,8 +9,10 @@ from tl_cli.commands.setup import (
     _bundled_skill_blurbs,
     _find_claude_binary,
     _install_command_shim,
+    _installed_plugin_version,
     _remove_matching_standalone_skills,
     _trees_identical,
+    _update_plugin,
 )
 
 
@@ -191,3 +194,135 @@ class TestFindClaudeBinary:
         if sys.platform == "win32":
             monkeypatch.setenv("APPDATA", str(tmp_path / "AppData" / "Roaming"))
         assert _find_claude_binary() is None
+
+
+class TestInstalledPluginVersion:
+    def _record(self, tmp_path, monkeypatch, payload):
+        plugins = tmp_path / "plugins"
+        plugins.mkdir(parents=True, exist_ok=True)
+        monkeypatch.setattr(setup, "CLAUDE_PLUGINS_DIR", plugins)
+        (plugins / "installed_plugins.json").write_text(json.dumps(payload), encoding="utf-8")
+        return plugins
+
+    def test_reads_version_from_install_record(self, tmp_path, monkeypatch):
+        self._record(tmp_path, monkeypatch, {"version": 2, "plugins": {setup.PLUGIN_KEY: [{"scope": "user", "version": "0.7.2"}]}})
+        assert _installed_plugin_version() == "0.7.2"
+
+    def test_prefers_user_scope(self, tmp_path, monkeypatch):
+        self._record(
+            tmp_path,
+            monkeypatch,
+            {"plugins": {setup.PLUGIN_KEY: [{"scope": "project", "version": "0.1.0"}, {"scope": "user", "version": "0.9.9"}]}},
+        )
+        assert _installed_plugin_version() == "0.9.9"
+
+    def test_ignores_unknown_version(self, tmp_path, monkeypatch):
+        self._record(tmp_path, monkeypatch, {"plugins": {setup.PLUGIN_KEY: [{"scope": "user", "version": "unknown"}]}})
+        assert _installed_plugin_version() is None
+
+    def test_missing_file(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(setup, "CLAUDE_PLUGINS_DIR", tmp_path / "plugins")
+        assert _installed_plugin_version() is None
+
+    def test_unreadable_record_is_unknown_not_outdated(self, tmp_path, monkeypatch):
+        plugins = tmp_path / "plugins"
+        plugins.mkdir(parents=True)
+        monkeypatch.setattr(setup, "CLAUDE_PLUGINS_DIR", plugins)
+        (plugins / "installed_plugins.json").write_text("{not json", encoding="utf-8")
+        assert _installed_plugin_version() is None
+        assert not [w for w in setup.check_plugin_version() if "Claude Code plugin" in w]
+
+    def test_unexpected_shape_is_unknown(self, tmp_path, monkeypatch):
+        self._record(tmp_path, monkeypatch, {"plugins": {setup.PLUGIN_KEY: {"scope": "user", "version": "0.7.2"}}})
+        assert _installed_plugin_version() is None
+
+
+class TestCheckPluginVersion:
+    def test_warns_on_record_behind_cli(self, tmp_path, monkeypatch):
+        plugins = tmp_path / "plugins"
+        plugins.mkdir(parents=True)
+        monkeypatch.setattr(setup, "CLAUDE_PLUGINS_DIR", plugins)
+        monkeypatch.setattr(setup, "OPENCODE_SKILLS_DIR", tmp_path / "opencode")
+        monkeypatch.setattr(setup, "AGENTS_SKILLS_DIR", tmp_path / "agents")
+        (plugins / "installed_plugins.json").write_text(
+            json.dumps({"plugins": {setup.PLUGIN_KEY: [{"scope": "user", "version": "0.7.2"}]}}), encoding="utf-8"
+        )
+        # A stamp claiming the current version must not mask the real one.
+        (plugins / "tl-cli").mkdir()
+        (plugins / "tl-cli" / ".version").write_text(setup.__version__)
+
+        warnings = setup.check_plugin_version()
+        assert any("0.7.2" in w for w in warnings)
+
+    def test_falls_back_to_stamp_without_record(self, tmp_path, monkeypatch):
+        plugins = tmp_path / "plugins"
+        (plugins / "tl-cli").mkdir(parents=True)
+        monkeypatch.setattr(setup, "CLAUDE_PLUGINS_DIR", plugins)
+        monkeypatch.setattr(setup, "OPENCODE_SKILLS_DIR", tmp_path / "opencode")
+        monkeypatch.setattr(setup, "AGENTS_SKILLS_DIR", tmp_path / "agents")
+        (plugins / "tl-cli" / ".version").write_text("0.1.0")
+
+        assert any("0.1.0" in w for w in setup.check_plugin_version())
+
+    def test_silent_when_nothing_installed(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(setup, "CLAUDE_PLUGINS_DIR", tmp_path / "plugins")
+        monkeypatch.setattr(setup, "OPENCODE_SKILLS_DIR", tmp_path / "opencode")
+        monkeypatch.setattr(setup, "AGENTS_SKILLS_DIR", tmp_path / "agents")
+        assert setup.check_plugin_version() == []
+
+
+class TestUpdatePlugin:
+    def test_already_latest_is_not_a_change(self, monkeypatch):
+        monkeypatch.setattr(setup, "_run_claude", lambda args, b: (True, 'tl-cli is already at the latest version (0.9.9).'))
+        assert _update_plugin("claude") == (True, False, 'tl-cli is already at the latest version (0.9.9).')
+
+    def test_version_advance_is_a_change(self, monkeypatch):
+        monkeypatch.setattr(setup, "_run_claude", lambda args, b: (True, 'Plugin "tl-cli" updated from 0.7.2 to 0.9.9.'))
+        ok, changed, _ = _update_plugin("claude")
+        assert (ok, changed) == (True, True)
+
+    def test_failure_is_not_a_change(self, monkeypatch):
+        monkeypatch.setattr(setup, "_run_claude", lambda args, b: (False, "boom"))
+        assert _update_plugin("claude") == (False, False, "boom")
+
+
+class TestSetupCallSequence:
+    def _stub_env(self, tmp_path, monkeypatch, record=None):
+        plugin_root = tmp_path / "plugin"
+        (plugin_root / "skills").mkdir(parents=True)
+        plugins = tmp_path / "plugins"
+        plugins.mkdir()
+        if record is not None:
+            (plugins / "installed_plugins.json").write_text(json.dumps(record), encoding="utf-8")
+        monkeypatch.setattr(setup, "_find_plugin_root", lambda: plugin_root)
+        monkeypatch.setattr(setup, "_find_claude_binary", lambda: "/usr/bin/claude")
+        monkeypatch.setattr(setup, "CLAUDE_PLUGINS_DIR", plugins)
+        monkeypatch.setattr(setup, "CLAUDE_SKILLS_DIR", tmp_path / "skills")
+        monkeypatch.setattr(setup, "CLAUDE_COMMANDS_DIR", tmp_path / "commands")
+        calls = []
+        monkeypatch.setattr(setup, "_run_claude", lambda args, b: (calls.append(args), (True, "ok"))[1])
+        return calls, plugins
+
+    def test_interactive_updates_after_install(self, tmp_path, monkeypatch):
+        calls, _ = self._stub_env(tmp_path, monkeypatch)
+        setup.setup_claude(json_output=False, toon_output=False)
+        assert calls.index(["plugin", "update", setup.PLUGIN_KEY]) > calls.index(["plugin", "install", setup.PLUGIN_KEY])
+
+    def test_noninteractive_updates_after_install(self, tmp_path, monkeypatch, capsys):
+        calls, _ = self._stub_env(tmp_path, monkeypatch)
+        setup._setup_noninteractive()
+        assert calls.index(["plugin", "update", setup.PLUGIN_KEY]) > calls.index(["plugin", "install", setup.PLUGIN_KEY])
+        assert json.loads(capsys.readouterr().out)["plugin_updated"] is True
+
+    def test_stamp_records_installed_version_not_cli_version(self, tmp_path, monkeypatch, capsys):
+        record = {"plugins": {setup.PLUGIN_KEY: [{"scope": "user", "version": "0.7.2"}]}}
+        _, plugins = self._stub_env(tmp_path, monkeypatch, record=record)
+        setup._setup_noninteractive()
+        assert (plugins / "tl-cli" / ".version").read_text() == "0.7.2"
+        assert json.loads(capsys.readouterr().out)["plugin_version"] == "0.7.2"
+
+    def test_standalone_fallback_stamps_cli_version(self, tmp_path, monkeypatch, capsys):
+        _, plugins = self._stub_env(tmp_path, monkeypatch)
+        monkeypatch.setattr(setup, "_find_claude_binary", lambda: None)
+        setup._setup_noninteractive()
+        assert (plugins / "tl-cli" / ".version").read_text() == setup.__version__