@xcraftmind/mastermind 0.28.1 → 0.29.0

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

@@ -1,187 +0,0 @@
----
-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

@@ -1,79 +0,0 @@
-# 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

@@ -1,83 +0,0 @@
-# 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

@@ -1,285 +0,0 @@
-#!/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

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