@xcraftmind/mastermind 0.24.0 → 0.25.0

package/share/skills/doc-stub-sync/SKILL.md

@@ -0,0 +1,187 @@
+---
+name: doc-stub-sync
+description: 'Sync local documentation stubs with their current online versions — finds files matching a stub pattern (default `Fetch live documentation: <URL>`), compares content hashes, refetches changed pages, reports diffs. Use when the user says "update docs", "sync docs with online sources", "refresh local docs", or has a folder of stub files pointing at upstream URLs.'
+metadata:
+  version: 0.1.0
+  authors:
+    - mastermind
+  tags:
+    - docs
+    - automation
+    - sync
+  model: sonnet
+  requires:
+    - Bash
+    - Python 3.10+ (for the bundled script), OR any HTTP-capable runtime if doing it manually
+---
+
+# Documentation Stub Sync
+
+Keeps a tree of local documentation files in sync with their online sources. Works on the **stub-link pattern**: each local file contains a marker line like `Fetch live documentation: https://...` pointing at the canonical upstream URL. The skill finds those stubs, checks whether the upstream changed, and refetches only what's stale.
+
+This is for the specific workflow where you maintain a local mirror of upstream docs (vendor reference, framework docs, internal wiki snapshots) as part of your personal or team knowledge base. **Not** a general "fix all my docs" tool.
+
+## When to use
+
+- User says "update docs", "sync docs with online sources", "refresh local docs"
+- User points at a folder and says "the stubs in here are stale"
+- A local docs tree has files matching the stub pattern and the user wants them current
+- Do NOT use to *write* new documentation. Use a writing-focused skill for that.
+- Do NOT use on files that don't have the stub marker — the skill will skip them, but you shouldn't even point it there.
+
+## Prerequisites
+
+- A local directory containing markdown files with the stub pattern
+- Bash + Python 3.10+ if using the bundled script (`scripts/doc_update.py`)
+- Network access for the URLs in the stubs
+- Optional: configurable stub pattern (default `Fetch live documentation: <URL>`)
+
+## Steps
+
+### 1. Inventory
+
+Find every file matching the stub pattern under the target directory:
+
+```bash
+grep -rl "Fetch live documentation:" <target-dir> --include="*.md"
+```
+
+Then for each matched file, extract the URL. Report: total count, list of unique URLs, files-per-URL if any URL repeats. Show this to the user **before** any network requests — confirm scope.
+
+### 2. Confirm with the user
+
+Show the inventory and ask before proceeding. For >10 files, also note expected time (rule of thumb: ~1.5s/file with rate limiting). For >100 files, suggest breaking into batches by subdirectory.
+
+### 3. Detect what changed
+
+For each stub file:
+- Fetch the upstream URL (with timeout, single retry on transient failure)
+- Extract the main content region (`<main>`, `<article>`, or the largest content block)
+- Compute a hash (SHA-256 of normalized text — strip whitespace at line ends, collapse runs of blank lines)
+- Compute the same hash on the local file's content body (excluding the stub line)
+- If hashes match: **skip** (already current)
+- If hashes differ: **mark for update**
+- If URL returns ≥400 or times out: **mark unreachable**
+
+Rate limit: minimum 1 second between requests to the same host. Use the bundled script — `scripts/doc_update.py` — for the actual implementation. The script handles rate limiting, retry, and parallelism within rate limits.
+
+### 4. Update changed files
+
+For each "mark for update" file:
+- Build the new body: extracted content + the stub line preserved at the bottom
+- Write atomically (tmp file + rename) to avoid partial writes
+- Log: old hash → new hash, byte delta
+
+Never delete files. Never modify files that don't have the stub marker. Never touch files outside the target directory.
+
+### 5. Report
+
+Output a two-part report:
+
+**Machine-readable JSON** (for downstream tooling):
+```json
+{
+  "summary": {
+    "scanned": 96,
+    "updated": 12,
+    "skipped_current": 82,
+    "unreachable": 2,
+    "errors": 0,
+    "duration_seconds": 187
+  },
+  "updated": [
+    {"path": "anthropic/configuration/settings.md", "url": "...", "old_hash": "a1b2...", "new_hash": "c3d4...", "delta_bytes": 412}
+  ],
+  "unreachable": [
+    {"path": "...", "url": "...", "reason": "404 Not Found"}
+  ],
+  "errors": []
+}
+```
+
+**Human summary** (one paragraph + the deltas):
+```
+Synced 96 stubs in 3 minutes. Updated 12 files (largest delta: configuration/settings.md +412 B). 82 already current. 2 unreachable (404): see report. No write errors.
+```
+
+## Outputs
+
+- The JSON + human summary shown above
+- Optionally write the JSON to `<target-dir>/.doc-stub-sync-report.json` if the user asks for it
+- Only file modifications: the stub files themselves, atomically rewritten
+
+## ALWAYS / NEVER
+
+**ALWAYS**
+- Rate-limit (≥1s between requests to the same host)
+- Show inventory and ask for confirmation before any network requests
+- Preserve the stub marker line in the rewritten file
+- Atomic writes (tmp + rename)
+- Continue on individual file failures; never abort the whole batch on one error
+- Report unreachable URLs in the final summary
+
+**NEVER**
+- Modify files outside the target directory
+- Modify files that don't contain the stub marker
+- Delete files
+- Overwrite files where the hash is unchanged (it's a no-op, but skip the write — preserves mtime for downstream tools that watch it)
+- Fire requests at the same host faster than the rate limit, even on retries
+- Trust the upstream content blindly — strip scripts, styles, and tracking elements before hashing/storing
+
+## Examples
+
+### Full sync
+
+**User:** "Sync everything under `~/Documents/kb/anthropic/`."
+
+**Agent:**
+```
+Found 96 stub files under ~/Documents/kb/anthropic/. They reference 96 unique URLs across 3 hosts (docs.claude.com, www.anthropic.com, github.com/anthropics).
+
+Estimated time: ~3 minutes with rate limiting.
+
+Proceed? [yes / no / dry-run]
+```
+
+After confirmation, runs `scripts/doc_update.py` and emits the JSON + summary report.
+
+### Targeted
+
+**User:** "Just the configuration subdirectory."
+
+**Agent:**
+```
+Found 5 stub files under ~/Documents/kb/anthropic/configuration/:
+  - settings.md → docs.claude.com/.../settings
+  - model-config.md → docs.claude.com/.../model-config
+  - terminal-config.md → docs.claude.com/.../terminal
+  - memory.md → docs.claude.com/.../memory
+  - statusline.md → docs.claude.com/.../statusline
+
+Estimated time: ~10 seconds. Proceed?
+```
+
+### Dry-run
+
+**User:** "What would change if I ran it now?"
+
+**Agent:** Runs the hash comparison only, skipping the update step. Reports which files *would* change and which would stay.
+
+## References
+
+- [`references/url-patterns.md`](references/url-patterns.md) — recognized stub formats and how to add a new one
+- [`references/error-handling.md`](references/error-handling.md) — HTTP error codes and how the skill responds to each
+- [`scripts/doc_update.py`](scripts/doc_update.py) — bundled implementation (Python 3.10+)
+- [`scripts/requirements.txt`](scripts/requirements.txt) — Python deps for the script
+
+## Customizing the stub pattern
+
+Default: `Fetch live documentation: <URL>` (case-sensitive, URL is the rest of the line).
+
+To use a different pattern, pass `--stub-pattern` to the script with a regex containing one capture group for the URL. Example for a different convention:
+
+```bash
+python scripts/doc_update.py --stub-pattern 'Source: (https?://\S+)' <target-dir>
+```
+
+The skill body assumes the default pattern unless the user tells you otherwise. If you see they're using a different convention, ask first before assuming.

package/share/skills/doc-stub-sync/references/error-handling.md

@@ -0,0 +1,79 @@
+# Error handling — HTTP responses and how the skill reacts
+
+Reference for the [`doc-stub-sync`](../SKILL.md) skill. The script behavior is in [`../scripts/doc_update.py`](../scripts/doc_update.py).
+
+## How errors are classified
+
+Every stub processed ends up in one of four buckets in the report:
+
+- `updated` — content changed, file rewritten
+- `current` — content unchanged, file untouched
+- `unreachable` — request failed or returned ≥400, file untouched
+- `error` — local issue (permissions, disk, encoding), file untouched
+
+A stub never silently fails. Every problem lands in one bucket and is reported.
+
+## HTTP response handling
+
+| Status | Bucket | Skill action |
+|---|---|---|
+| 2xx | `current` / `updated` | Parse, hash, compare, maybe rewrite |
+| 301, 302, 307, 308 | (followed) | The HTTP client follows redirects automatically; the *final* response is what the skill evaluates. If the final response is ≥400, treat as unreachable. |
+| 304 Not Modified | `current` | Treated as no-change. (Note: the bundled script doesn't send `If-Modified-Since` yet — 304 in practice means the server volunteered it.) |
+| 401, 403 | `unreachable` | Auth required or forbidden. Don't retry with credentials — surface to user and stop. |
+| 404, 410 | `unreachable` | Upstream page is gone. The user has to decide: update the stub's URL, delete the file, or accept the staleness. The skill does NOT auto-delete. |
+| 408, 429, 503, 504 | `unreachable` (after one retry) | Transient. Script retries once after a 2-second pause. Still failing → unreachable. |
+| 5xx (other) | `unreachable` (after one retry) | Same handling as transient. |
+| Network timeout | `unreachable` (after one retry) | Single retry with backoff, then give up for this run. |
+| DNS / connection refused | `unreachable` | No retry — the host isn't there. |
+
+## Retry policy
+
+The script retries **once** on a network-level failure (timeout, connection error, DNS). It does **not** retry on HTTP status codes ≥400 — those represent a definitive answer from the server, not a transient transport issue.
+
+Why one retry, not more:
+- Most transient failures are resolved by waiting 1-2 seconds
+- More retries on a doc-sync job means slowing down the whole batch by minutes
+- 429 (rate limit) deserves a different response: respect the limit, don't hammer
+
+If the user is hitting 429 repeatedly, the fix is `--rate-limit` (raise it), not more retries.
+
+## Rate limiting
+
+The script enforces a per-host minimum interval between requests. Default: 1.0 second.
+
+This applies *per host*, not globally: syncing 50 stubs from `docs.claude.com` and 30 from `github.com` runs them in parallel as far as the rate limiter is concerned. Within each host, requests are serialized with the minimum gap.
+
+Raise `--rate-limit` to 2.0 or higher if the upstream is sensitive (small docs site, single-server) or you've seen 429s.
+
+## Local errors
+
+| Situation | Bucket | What to do |
+|---|---|---|
+| File not writable (permissions) | `error` | Surface to user. They fix the perms and re-run. |
+| Disk full | `error` | Surface. Don't keep trying. |
+| File contains invalid UTF-8 | (skipped at discovery) | These files aren't even inventoried. If the user expects them to be stubs, they have a separate problem. |
+| Atomic rename fails (race, cross-device tmp) | `error` | Surface the underlying OS error verbatim. Often means `tempfile.mkstemp` landed on a different filesystem than the target — usually a misconfigured `TMPDIR`. |
+
+## What the user sees on error
+
+Every error appears in two places:
+1. The JSON report (`errors` array, with `path`, `url`, `reason`)
+2. The human summary (count + first 3 reasons inline, full list pointer)
+
+Example human summary on errors:
+
+```
+Synced 96 stubs in 4 minutes. Updated 8. 80 already current. 6 unreachable (4×404, 2×timeout): see report. 2 errors (permission denied): see report.
+```
+
+If the run had *only* errors and no updates, exit code is non-zero — pipelines and cron jobs that depend on the script can detect this.
+
+## What the agent does with the report
+
+The skill's job is to **report**, not to **act on** errors. The user decides:
+- A 404 on a doc → maybe the upstream renamed it. Update the stub URL or delete the local file.
+- 401/403 → maybe the doc moved behind auth. Out of scope for this skill.
+- A permissions error → the user fixes the OS-level perms and re-runs.
+
+The skill does **not** edit stub URLs, delete files, or modify other files in response to errors. Those are destructive operations and they belong to the user (or to a separate, explicitly-invoked tool).

package/share/skills/doc-stub-sync/references/url-patterns.md

@@ -0,0 +1,83 @@
+# Stub URL patterns
+
+This reference covers stub formats the [`doc-stub-sync`](../SKILL.md) skill recognizes, and how to add new ones.
+
+## The default pattern
+
+```
+Fetch live documentation: https://docs.example.com/path/to/page
+```
+
+Regex: `Fetch live documentation:\s*(https?://\S+)`
+
+This is the format the bundled `scripts/doc_update.py` looks for unless overridden.
+
+### Why this pattern
+
+- **Easy to grep**: single grep across the whole tree finds every stub
+- **Self-documenting**: a human reading the file knows where the canonical source is
+- **One URL per file**: forces one-doc-per-stub-file, which simplifies sync logic
+- **Tool-agnostic prefix**: the words `Fetch live documentation:` are unlikely to appear in normal prose, so false matches are rare
+
+## Where the pattern goes inside the file
+
+The skill doesn't care about position — it greps the whole file. By convention:
+
+- **At the end of the file**, after a `---` separator, as a "source" footer
+- **In a frontmatter field** (e.g., `source: https://...`) — for that, switch to a frontmatter-aware pattern (see below)
+
+## Common alternative patterns
+
+If your knowledge base uses a different convention, pass `--stub-pattern` to the script. The pattern must be a Python regex with **exactly one capture group** that captures the URL.
+
+### Source-line convention
+
+```
+Source: https://docs.example.com/page
+```
+
+```bash
+python scripts/doc_update.py --stub-pattern 'Source:\s*(https?://\S+)' ./docs
+```
+
+### HTML-comment marker
+
+```html
+<!-- mirror: https://docs.example.com/page -->
+```
+
+```bash
+python scripts/doc_update.py --stub-pattern '<!--\s*mirror:\s*(https?://\S+)\s*-->' ./docs
+```
+
+### Frontmatter `source:` field
+
+```yaml
+---
+title: API Reference
+source: https://docs.example.com/api
+---
+```
+
+```bash
+python scripts/doc_update.py --stub-pattern '^source:\s*(https?://\S+)$' ./docs
+```
+
+Frontmatter matching is best done with the multiline flag — wrap the pattern in `(?m)` if needed: `'(?m)^source:\s*(https?://\S+)$'`.
+
+## Adding a new pattern to the standard
+
+If you find yourself using a new pattern across multiple projects, send a PR adding:
+
+1. An entry to this file under "Common alternative patterns"
+2. An example command line
+3. A short note on when this pattern is preferable
+
+Don't add a flag to the script for every pattern — the regex flag is general enough. Only the default in `DEFAULT_STUB_PATTERN` is special, and we don't change the default casually (it would break every existing local KB using this skill).
+
+## Pattern gotchas
+
+- **Greediness**: `https?://.+` will eat trailing punctuation. Use `\S+` to stop at whitespace.
+- **Multiline**: stubs that wrap across lines aren't supported — keep the URL on the same line as the marker.
+- **Query strings and fragments**: included by default. If you want to strip `?utm_*` and `#fragments` for hashing, do it in the script, not the regex.
+- **Multiple stubs per file**: only the *first* match wins. If a file points at multiple URLs, it's not a stub file — it's a hand-edited doc, leave it alone.

package/share/skills/doc-stub-sync/scripts/doc_update.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""
+Sync local documentation stubs with their current online versions.
+
+See ../SKILL.md for the workflow this script implements.
+Run with --help for CLI usage.
+"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import hashlib
+import json
+import os
+import re
+import sys
+import tempfile
+import time
+from collections import defaultdict
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlparse
+
+import requests
+from bs4 import BeautifulSoup
+
+DEFAULT_STUB_PATTERN = r"Fetch live documentation:\s*(https?://\S+)"
+DEFAULT_TIMEOUT_SECONDS = 15
+DEFAULT_RATE_LIMIT_SECONDS = 1.0
+USER_AGENT = "mastermind-doc-stub-sync/0.1 (+https://github.com/aglumova/mastermind)"
+
+
+@dataclasses.dataclass
+class StubFile:
+    path: Path
+    url: str
+
+
+@dataclasses.dataclass
+class UpdateResult:
+    path: str
+    url: str
+    status: str  # "updated" | "current" | "unreachable" | "error"
+    old_hash: Optional[str] = None
+    new_hash: Optional[str] = None
+    delta_bytes: int = 0
+    reason: Optional[str] = None
+
+
+def find_stubs(root: Path, pattern: re.Pattern) -> list[StubFile]:
+    stubs: list[StubFile] = []
+    for path in root.rglob("*.md"):
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, PermissionError):
+            continue
+        match = pattern.search(text)
+        if match:
+            stubs.append(StubFile(path=path, url=match.group(1).strip()))
+    return stubs
+
+
+def normalize_text(text: str) -> str:
+    """Strip line-end whitespace and collapse blank runs for stable hashing."""
+    lines = [line.rstrip() for line in text.splitlines()]
+    out: list[str] = []
+    prev_blank = False
+    for line in lines:
+        if not line:
+            if not prev_blank:
+                out.append("")
+            prev_blank = True
+        else:
+            out.append(line)
+            prev_blank = False
+    return "\n".join(out).strip() + "\n"
+
+
+def content_hash(text: str) -> str:
+    return hashlib.sha256(normalize_text(text).encode("utf-8")).hexdigest()
+
+
+def local_body(text: str, pattern: re.Pattern) -> str:
+    """The local file's body, with the stub line removed for fair comparison."""
+    return pattern.sub("", text).strip()
+
+
+def extract_main(html: str) -> tuple[str, str]:
+    """Return (title, main-text) extracted from the upstream HTML."""
+    soup = BeautifulSoup(html, "html.parser")
+    for tag in soup(["script", "style", "noscript", "iframe", "nav", "footer"]):
+        tag.decompose()
+    main = soup.find("main") or soup.find("article") or soup.find("body") or soup
+    text = main.get_text(separator="\n")
+    title_tag = soup.find("title")
+    title = (
+        title_tag.get_text().split("|")[0].strip()
+        if title_tag
+        else urlparse(soup.find("link", rel="canonical").get("href", ""))
+        .path.rstrip("/")
+        .rsplit("/", 1)[-1]
+        if soup.find("link", rel="canonical")
+        else ""
+    )
+    return title, text
+
+
+def fetch(url: str, timeout: float) -> requests.Response:
+    return requests.get(url, timeout=timeout, headers={"User-Agent": USER_AGENT})
+
+
+def fetch_with_retry(url: str, timeout: float) -> requests.Response:
+    try:
+        return fetch(url, timeout)
+    except requests.exceptions.RequestException:
+        time.sleep(2)
+        return fetch(url, timeout)
+
+
+def build_updated_content(title: str, body_text: str, url: str) -> str:
+    header = f"# {title}\n\n" if title else ""
+    return f"{header}{body_text.strip()}\n\n---\n\nFetch live documentation: {url}\n"
+
+
+def write_atomic(path: Path, content: str) -> None:
+    tmp_fd, tmp_path = tempfile.mkstemp(dir=path.parent, prefix=".tmp-", suffix=".md")
+    try:
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            f.write(content)
+        os.replace(tmp_path, path)
+    except Exception:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        raise
+
+
+def process_stub(
+    stub: StubFile,
+    pattern: re.Pattern,
+    timeout: float,
+    dry_run: bool,
+) -> UpdateResult:
+    try:
+        response = fetch_with_retry(stub.url, timeout)
+    except requests.exceptions.RequestException as exc:
+        return UpdateResult(
+            path=str(stub.path),
+            url=stub.url,
+            status="unreachable",
+            reason=f"request failed: {exc}",
+        )
+
+    if response.status_code >= 400:
+        return UpdateResult(
+            path=str(stub.path),
+            url=stub.url,
+            status="unreachable",
+            reason=f"{response.status_code} {response.reason}",
+        )
+
+    title, upstream_text = extract_main(response.text)
+    new_content = build_updated_content(title, upstream_text, stub.url)
+    new_hash = content_hash(new_content)
+
+    try:
+        old_text = stub.path.read_text(encoding="utf-8")
+    except Exception as exc:
+        return UpdateResult(
+            path=str(stub.path), url=stub.url, status="error", reason=str(exc)
+        )
+
+    old_hash = content_hash(local_body(old_text, pattern))
+    cmp_hash = content_hash(local_body(new_content, pattern))
+
+    if old_hash == cmp_hash:
+        return UpdateResult(
+            path=str(stub.path),
+            url=stub.url,
+            status="current",
+            old_hash=old_hash,
+            new_hash=cmp_hash,
+        )
+
+    delta = len(new_content.encode("utf-8")) - len(old_text.encode("utf-8"))
+    if not dry_run:
+        try:
+            write_atomic(stub.path, new_content)
+        except Exception as exc:
+            return UpdateResult(
+                path=str(stub.path), url=stub.url, status="error", reason=str(exc)
+            )
+    return UpdateResult(
+        path=str(stub.path),
+        url=stub.url,
+        status="updated",
+        old_hash=old_hash,
+        new_hash=cmp_hash,
+        delta_bytes=delta,
+    )
+
+
+def run(
+    root: Path,
+    stub_pattern: str,
+    rate_limit_seconds: float,
+    timeout_seconds: float,
+    dry_run: bool,
+) -> dict:
+    pattern = re.compile(stub_pattern)
+    stubs = find_stubs(root, pattern)
+    if not stubs:
+        return {
+            "summary": {"scanned": 0, "updated": 0, "skipped_current": 0, "unreachable": 0, "errors": 0, "duration_seconds": 0},
+            "updated": [],
+            "unreachable": [],
+            "errors": [],
+        }
+
+    started = time.monotonic()
+    last_request_per_host: dict[str, float] = defaultdict(float)
+    results: list[UpdateResult] = []
+
+    for stub in stubs:
+        host = urlparse(stub.url).netloc
+        wait = (last_request_per_host[host] + rate_limit_seconds) - time.monotonic()
+        if wait > 0:
+            time.sleep(wait)
+        last_request_per_host[host] = time.monotonic()
+        results.append(process_stub(stub, pattern, timeout_seconds, dry_run))
+
+    summary = {
+        "scanned": len(results),
+        "updated": sum(1 for r in results if r.status == "updated"),
+        "skipped_current": sum(1 for r in results if r.status == "current"),
+        "unreachable": sum(1 for r in results if r.status == "unreachable"),
+        "errors": sum(1 for r in results if r.status == "error"),
+        "duration_seconds": round(time.monotonic() - started, 1),
+        "dry_run": dry_run,
+    }
+    return {
+        "summary": summary,
+        "updated": [dataclasses.asdict(r) for r in results if r.status == "updated"],
+        "unreachable": [dataclasses.asdict(r) for r in results if r.status == "unreachable"],
+        "errors": [dataclasses.asdict(r) for r in results if r.status == "error"],
+    }
+
+
+def cli(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(description="Sync local doc stubs with online sources.")
+    parser.add_argument("target_dir", type=Path, help="Root directory containing stub markdown files.")
+    parser.add_argument("--stub-pattern", default=DEFAULT_STUB_PATTERN,
+                        help="Regex with one capture group for the URL. Default: %(default)r")
+    parser.add_argument("--rate-limit", type=float, default=DEFAULT_RATE_LIMIT_SECONDS,
+                        help="Minimum seconds between requests to the same host. Default: %(default)s")
+    parser.add_argument("--timeout", type=float, default=DEFAULT_TIMEOUT_SECONDS,
+                        help="Per-request timeout in seconds. Default: %(default)s")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Detect changes but do not write files. Report what would change.")
+    parser.add_argument("--report-file", type=Path,
+                        help="If set, write the JSON report to this path.")
+    args = parser.parse_args(argv)
+
+    if not args.target_dir.is_dir():
+        print(f"error: target_dir is not a directory: {args.target_dir}", file=sys.stderr)
+        return 2
+
+    report = run(
+        root=args.target_dir,
+        stub_pattern=args.stub_pattern,
+        rate_limit_seconds=args.rate_limit,
+        timeout_seconds=args.timeout,
+        dry_run=args.dry_run,
+    )
+
+    output_json = json.dumps(report, indent=2)
+    print(output_json)
+    if args.report_file:
+        args.report_file.write_text(output_json + "\n", encoding="utf-8")
+
+    return 0 if report["summary"]["errors"] == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(cli(sys.argv[1:]))

package/share/skills/doc-stub-sync/scripts/requirements.txt

@@ -0,0 +1,2 @@
+requests>=2.31
+beautifulsoup4>=4.12