thoughtleaders-cli 0.7.11__tar.gz → 0.7.12__tar.gz

{thoughtleaders_cli-0.7.11 → thoughtleaders_cli-0.7.12}/.claude-plugin/plugin.json

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

{thoughtleaders_cli-0.7.11 → thoughtleaders_cli-0.7.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoughtleaders-cli
-Version: 0.7.11
+Version: 0.7.12
 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.7.11 → thoughtleaders_cli-0.7.12}/pyproject.toml

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

{thoughtleaders_cli-0.7.11 → thoughtleaders_cli-0.7.12}/skills/tl/SKILL.md

@@ -446,7 +446,7 @@ If unsure about what information to find where, read the [references/postgresql-
 | Pre-insert validation queries (joining `adspot ↔ channel ↔ profile ↔ org` to confirm MSN, integration=1, persona, plan) | **Available** via `tl db pg`. | One SELECT joining the four tables. Use `thoughtleaders_channel.media_selling_network_join_date IS NOT NULL` for MSN, `thoughtleaders_adspot.integration = 1` for mention adspots, `thoughtleaders_profile.persona` for the persona code (see persona constants in `references/postgres-schema.md`). |
 | Firebolt cross-table or join queries; filtering on non-indexed columns in WHERE | **Unavailable** — not accepted. | Fetch a wider slice keyed on `channel_id` (and optionally `id`), filter the rest in `jq`/Python. |
 | ES `query_string`, `regexp`, `wildcard`, `fuzzy`, `more_like_this`, parent/child joins; any `script_*`; multiple aggregations in one body | **Unavailable** — not accepted. | Rewrite using `term`/`terms`/`match`/`bool`/`nested`. For multi-agg dashboards, run multiple `tl db es` calls and combine client-side. For "similar"-style queries, try `tl channels similar` / `tl brands similar` (server-implemented similarity search). |
-| ES deep pagination beyond `from+size = 10,000` | **Unavailable** — `scroll`, `pit`, and `search_after` aren't allowlisted; hits past the first 10,000 of a query are unreachable. | A single `size: 10000` page covers everything reachable. For bigger sweeps, slice into `publication_date` range windows of <10k hits each. |
+| ES deep pagination beyond `from+size = 10,000` | **Available** via `search_after` (stateless cursor); `scroll` and `pit` remain unavailable. | Sort with a unique tiebreaker (e.g. `id`), then pass the response envelope's `next_search_after` back as `search_after` in the next call, keeping `query`/`sort` identical and `from` at 0. See the ES reference's *Deep pagination* section. |
 | ES index introspection (`_cat/indices`, mappings) | **Unavailable** — only `_search` is wired. | Read [references/elasticsearch-schema.md](references/elasticsearch-schema.md). It's manually maintained — update it when you discover new fields. |
 | Schema introspection on Postgres (`information_schema.columns`, `pg_class`, …) | **Partial** — catalog-resolving casts and many `pg_*` helpers are blocked. | Use `tl schema pg` for the live table/column listing, or read [references/postgres-schema.md](references/postgres-schema.md). |
 

{thoughtleaders_cli-0.7.11 → thoughtleaders_cli-0.7.12}/skills/tl/references/elasticsearch-schema.md

@@ -21,8 +21,9 @@ Output flags: `--json`, `--csv`, `--md`, `--toon`. The CLI flattens hits into ro
 
 See the output of `tl db es`" for the object schema. Highlights:
 
-- **Top-level keys** accepted: `query`, `aggs`/`aggregations`, `sort`, `_source`, `size`, `from`, `track_total_hits`, `highlight`, `fields`, `min_score`, `timeout`, `collapse`, `post_filter`. Anything else (incl. `scroll`, `pit`, `search_after`, `runtime_mappings`, `knn`) is not accepted.
-- `size` ≤ 10,000. `from + size` ≤ 10,000 — hits beyond the first 10,000 of a query are unreachable; narrow the query (e.g. `publication_date` ranges) instead of paging deeper.
+- **Top-level keys** accepted: `query`, `aggs`/`aggregations`, `sort`, `_source`, `size`, `from`, `search_after`, `track_total_hits`, `highlight`, `fields`, `min_score`, `timeout`, `collapse`, `post_filter`. Anything else (incl. `scroll`, `pit`, `runtime_mappings`, `knn`) is not accepted.
+- `size` ≤ 10,000. `from + size` ≤ 10,000 — to page past 10,000 hits use `search_after` (see *Deep pagination* below), not `from`.
+- `search_after` must be a non-empty array of ≤ 10 scalar sort values, requires an explicit `sort`, and `from` must be 0 or omitted.
 - **Accepted query types** include `term`/`terms`/`match`/`bool`/`nested`/`range`/`exists`/`match_phrase`. `query_string`, `regexp`, `wildcard`, `fuzzy`, `more_like_this`, `has_child`, `has_parent`, `parent_id` are not accepted.
 - **No scripts** — any key whose name contains `script` is not accepted.
 - **At most one aggregation total** counted recursively (top-level + sub-agg = 2 = not accepted). Run multiple calls for multi-metric work.
@@ -215,24 +216,29 @@ tl db es '{
 
 For more dimensions, run multiple `tl db es` calls and join client-side.
 
-### Deep sweeps — window by date, don't page past 10k
+### Deep pagination — `search_after`
 
-`from + size` is capped at 10,000 and cursor keys (`search_after`, `scroll`, `pit`) are not accepted, so hits beyond the first 10,000 of any one query are unreachable. For result sets bigger than that, slice the query into non-overlapping `publication_date` (or other range-field) windows, each under 10,000 hits, and sweep window by window:
+`from + size` is capped at 10,000, and the stateful cursors (`scroll`, `pit`) are not accepted. To page past 10,000 hits, use the stateless `search_after` cursor: sort deterministically with a unique tiebreaker (the `id` field — not `_id`), then pass each response's `next_search_after` envelope value back as `search_after` in the next request, keeping the same `query` and `sort`:
 
 ```bash
-# One window — repeat with shifted date ranges until the full period is covered
+# First page
 tl db es '{
   "size": 10000,
-  "track_total_hits": true,
-  "query": {"bool": {"filter": [
-    {"term": {"channel.id": 12345}},
-    {"range": {"publication_date": {"gte": "2025-01-01", "lt": "2025-04-01"}}}
-  ]}},
-  "sort": [{"publication_date": "asc"}]
+  "query": {"term": {"channel.id": 12345}},
+  "sort": [{"publication_date": "asc"}, {"id": "asc"}]
+}'
+# → envelope includes "next_search_after": ["2025-09-14", "12345:abc123"]
+
+# Next page — identical query & sort, plus the cursor
+tl db es '{
+  "size": 10000,
+  "query": {"term": {"channel.id": 12345}},
+  "sort": [{"publication_date": "asc"}, {"id": "asc"}],
+  "search_after": ["2025-09-14", "12345:abc123"]
 }'
 ```
 
-Check `total` per window — if a window exceeds 10,000, split it further.
+Repeat until a page comes back short (`next_search_after` is absent on an empty page). Pages are not a consistent snapshot — concurrent indexing can occasionally duplicate or skip a boundary row, which is fine for analytics sweeps. Date-range windowing (filtering by `publication_date` ranges) remains a good alternative when you want resumable, idempotent slices.
 
 ## Text analyzer behavior
 

{thoughtleaders_cli-0.7.11 → thoughtleaders_cli-0.7.12}/src/tl_cli/__init__.py

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

{thoughtleaders_cli-0.7.11 → thoughtleaders_cli-0.7.12}/src/tl_cli/commands/setup.py

@@ -76,30 +76,66 @@ def _find_plugin_root() -> Path | None:
     return None
 
 
+def _newest_desktop_claude(base: Path, exe: str) -> Path | None:
+    """Pick the highest-version claude binary bundled by the Claude desktop app.
+
+    The desktop app keeps versioned copies under `<base>/<version>/<exe>`
+    (e.g. `%APPDATA%/Claude/claude-code/2.1.170/claude.exe`).
+    """
+    if not base.is_dir():
+        return None
+
+    def _version_key(d: Path) -> tuple[int, ...]:
+        try:
+            return tuple(int(part) for part in d.name.split("."))
+        except ValueError:
+            return (0,)
+
+    for version_dir in sorted(base.iterdir(), key=_version_key, reverse=True):
+        candidate = version_dir / exe
+        if candidate.is_file():
+            return candidate
+    return None
+
+
 def _find_claude_binary() -> str | None:
     """Find the claude binary on PATH, falling back to known install locations.
 
     On Windows the Claude Code installers often don't end up on the PATH of
     the shell running `tl` (stale PATH, PowerShell-only profile changes), so
     after `shutil.which` we probe the documented install targets directly:
-    the native installer (`~/.local/bin`) and the npm global prefix.
+    the native installer (`~/.local/bin`), the npm global prefix, and the
+    binaries bundled with the Claude desktop app. When `tl` itself runs
+    inside a Claude Code session, `CLAUDE_CODE_EXECPATH` points straight at
+    the running binary and wins.
     """
+    env_exec = os.environ.get("CLAUDE_CODE_EXECPATH")
+    if env_exec and Path(env_exec).is_file():
+        return env_exec
     found = shutil.which("claude")
     if found:
         return found
     home = Path.home()
     if sys.platform == "win32":
+        appdata = Path(os.environ.get("APPDATA", str(home / "AppData" / "Roaming")))
         candidates = [
             home / ".local" / "bin" / "claude.exe",
-            Path(os.environ.get("APPDATA", str(home / "AppData" / "Roaming"))) / "npm" / "claude.cmd",
+            appdata / "npm" / "claude.cmd",
+            _newest_desktop_claude(appdata / "Claude" / "claude-code", "claude.exe"),
         ]
     else:
+        desktop_base = (
+            home / "Library" / "Application Support" / "Claude" / "claude-code"
+            if sys.platform == "darwin"
+            else home / ".config" / "Claude" / "claude-code"
+        )
         candidates = [
             home / ".local" / "bin" / "claude",
             home / ".claude" / "local" / "claude",
+            _newest_desktop_claude(desktop_base, "claude"),
         ]
     for candidate in candidates:
-        if candidate.is_file():
+        if candidate is not None and candidate.is_file():
             return str(candidate)
     return None
 
@@ -204,10 +240,22 @@ def _install_command_shim() -> Path:
 
 
 def _trees_identical(a: Path, b: Path) -> bool:
-    """True if two directory trees contain the same files with the same contents."""
-    a_files = sorted(p.relative_to(a) for p in a.rglob("*") if p.is_file())
-    b_files = sorted(p.relative_to(b) for p in b.rglob("*") if p.is_file())
-    if a_files != b_files:
+    """True if two directory trees contain the same files with the same contents.
+
+    Python runtime artifacts (`__pycache__/`, `*.pyc`) are ignored — skills
+    that ship scripts grow them when the scripts run, and they shouldn't make
+    an otherwise-pristine copy look user-modified.
+    """
+
+    def _files(root: Path) -> list[Path]:
+        return sorted(
+            p.relative_to(root)
+            for p in root.rglob("*")
+            if p.is_file() and p.suffix != ".pyc" and "__pycache__" not in p.parts
+        )
+
+    a_files = _files(a)
+    if a_files != _files(b):
         return False
     return all(filecmp.cmp(a / rel, b / rel, shallow=False) for rel in a_files)
 

{thoughtleaders_cli-0.7.11 → thoughtleaders_cli-0.7.12}/tests/test_setup.py

@@ -64,6 +64,16 @@ class TestTreesIdentical:
             (d / "f.md").write_text(body, encoding="utf-8")
         assert not _trees_identical(tmp_path / "a", tmp_path / "b")
 
+    def test_ignores_pycache_artifacts(self, tmp_path):
+        for root in ("a", "b"):
+            d = tmp_path / root / "scripts"
+            d.mkdir(parents=True)
+            (d / "run.py").write_text("print()", encoding="utf-8")
+        cache = tmp_path / "b" / "scripts" / "__pycache__"
+        cache.mkdir()
+        (cache / "run.cpython-313.pyc").write_text("bytecode", encoding="utf-8")
+        assert _trees_identical(tmp_path / "a", tmp_path / "b")
+
     def test_extra_file(self, tmp_path):
         for root in ("a", "b"):
             d = tmp_path / root
@@ -128,11 +138,44 @@ class TestInstallCommandShim:
 
 
 class TestFindClaudeBinary:
+    def test_prefers_execpath_env(self, tmp_path, monkeypatch):
+        exe = tmp_path / "claude.exe"
+        exe.write_text("", encoding="utf-8")
+        monkeypatch.setenv("CLAUDE_CODE_EXECPATH", str(exe))
+        assert _find_claude_binary() == str(exe)
+
+    def test_ignores_stale_execpath_env(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_CODE_EXECPATH", str(tmp_path / "gone.exe"))
+        monkeypatch.setattr(setup.shutil, "which", lambda _: "/somewhere/claude")
+        assert _find_claude_binary() == "/somewhere/claude"
+
     def test_prefers_path(self, monkeypatch):
+        monkeypatch.delenv("CLAUDE_CODE_EXECPATH", raising=False)
         monkeypatch.setattr(setup.shutil, "which", lambda _: "/somewhere/claude")
         assert _find_claude_binary() == "/somewhere/claude"
 
+    def test_finds_newest_desktop_app_binary(self, tmp_path, monkeypatch):
+        monkeypatch.delenv("CLAUDE_CODE_EXECPATH", raising=False)
+        monkeypatch.setattr(setup.shutil, "which", lambda _: None)
+        monkeypatch.setattr(setup.Path, "home", staticmethod(lambda: tmp_path))
+        if sys.platform == "win32":
+            base = tmp_path / "AppData" / "Roaming" / "Claude" / "claude-code"
+            monkeypatch.setenv("APPDATA", str(tmp_path / "AppData" / "Roaming"))
+            exe = "claude.exe"
+        elif sys.platform == "darwin":
+            base = tmp_path / "Library" / "Application Support" / "Claude" / "claude-code"
+            exe = "claude"
+        else:
+            base = tmp_path / ".config" / "Claude" / "claude-code"
+            exe = "claude"
+        for version in ("2.1.165", "2.1.170"):
+            d = base / version
+            d.mkdir(parents=True)
+            (d / exe).write_text("", encoding="utf-8")
+        assert _find_claude_binary() == str(base / "2.1.170" / exe)
+
     def test_falls_back_to_local_bin(self, tmp_path, monkeypatch):
+        monkeypatch.delenv("CLAUDE_CODE_EXECPATH", raising=False)
         monkeypatch.setattr(setup.shutil, "which", lambda _: None)
         monkeypatch.setattr(setup.Path, "home", staticmethod(lambda: tmp_path))
         exe = "claude.exe" if sys.platform == "win32" else "claude"
@@ -142,6 +185,7 @@ class TestFindClaudeBinary:
         assert _find_claude_binary() == str(target)
 
     def test_not_found_anywhere(self, tmp_path, monkeypatch):
+        monkeypatch.delenv("CLAUDE_CODE_EXECPATH", raising=False)
         monkeypatch.setattr(setup.shutil, "which", lambda _: None)
         monkeypatch.setattr(setup.Path, "home", staticmethod(lambda: tmp_path))
         if sys.platform == "win32":