opencode-skills-collection 3.0.43 → 3.0.45

package/bundled-skills/papers-skill/scripts/papers.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""
+papers.py — Standalone academic paper toolkit (Skill-mode port of papers-mcp).
+Original MCP project: https://github.com/xwmxcz/papers-mcp
+
+Usage:
+  python papers.py search <query> [--limit 10]
+  python papers.py detail <paper_id>
+  python papers.py citations <paper_id> [--limit 10]
+  python papers.py arxiv <query> [--max-results 5]
+  python papers.py download <arxiv_id> [--save-dir .]
+  python papers.py read <pdf_path> [--max-pages 10]
+
+Dependencies: httpx, arxiv, PyMuPDF
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+from pathlib import Path
+
+# Force UTF-8 stdout on Windows so Chinese strings render correctly when
+# called via Bash / cmd / cron (Python 3.7+).
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+
+import httpx
+
+S2_BASE = "https://api.semanticscholar.org/graph/v1"
+S2_FIELDS = "paperId,title,abstract,year,citationCount,authors,externalIds,url"
+S2_RETRIES = 3
+S2_WAIT = 2  # seconds, exponential backoff base
+
+
+# ---------- HTTP helpers ----------
+
+def _s2_get(url: str, params: dict) -> dict:
+    """GET with rate-limit retry. Returns parsed JSON or {'error': ...}."""
+    for attempt in range(S2_RETRIES):
+        try:
+            r = httpx.get(
+                url,
+                params=params,
+                timeout=30.0,
+                headers={"User-Agent": "papers-skill/1.0"},
+            )
+            if r.status_code == 429:
+                time.sleep(S2_WAIT * (attempt + 1))
+                continue
+            r.raise_for_status()
+            return r.json()
+        except httpx.HTTPError as e:
+            if attempt == S2_RETRIES - 1:
+                return {"error": f"HTTP error: {e}"}
+            time.sleep(S2_WAIT * (attempt + 1))
+    return {"error": "rate limit, retries exhausted"}
+
+
+def _fmt_authors(authors: list, n: int = 3) -> str:
+    if not authors:
+        return "(unknown)"
+    names = [a.get("name", "?") for a in authors[:n]]
+    suffix = " et al." if len(authors) > n else ""
+    return ", ".join(names) + suffix
+
+
+# ---------- Commands ----------
+
+def cmd_search(args) -> str:
+    data = _s2_get(
+        f"{S2_BASE}/paper/search",
+        {"query": args.query, "limit": min(args.limit, 20), "fields": S2_FIELDS},
+    )
+    if "error" in data:
+        return f"搜索失败: {data['error']}"
+    papers = data.get("data", [])
+    if not papers:
+        return f"没有找到与 '{args.query}' 相关的论文"
+    out = [f"# 搜索结果 ({len(papers)} 篇)\n"]
+    for i, p in enumerate(papers, 1):
+        title = p.get("title", "无标题")
+        year = p.get("year", "?")
+        citations = p.get("citationCount", 0)
+        authors = _fmt_authors(p.get("authors", []))
+        abstract = (p.get("abstract") or "").strip()[:200]
+        ext = p.get("externalIds") or {}
+        arxiv_id = ext.get("ArXiv", "")
+        out.append(
+            f"## {i}. {title}\n"
+            f"**Authors:** {authors}  \n"
+            f"**Year:** {year} | **Citations:** {citations}  \n"
+            f"**S2 ID:** `{p.get('paperId')}`"
+            + (f" | **arXiv:** `{arxiv_id}`" if arxiv_id else "")
+            + "  \n"
+            f"**Abstract:** {abstract}{'...' if abstract else '(无摘要)'}\n"
+        )
+    return "\n".join(out)
+
+
+def cmd_detail(args) -> str:
+    pid = args.paper_id
+    # Auto-detect ID type
+    if pid.startswith(("10.", "ARXIV:", "DOI:", "MAG:", "PMID:", "PMCID:")):
+        lookup = pid
+    elif pid.isdigit() and len(pid) >= 10:
+        lookup = f"ARXIV:{pid}"
+    else:
+        lookup = pid  # assume raw S2 paperId
+    fields = S2_FIELDS + ",references.title,references.year,tldr"
+    data = _s2_get(f"{S2_BASE}/paper/{lookup}", {"fields": fields})
+    if "error" in data:
+        return f"查询失败: {data['error']}"
+    title = data.get("title", "无标题")
+    authors = _fmt_authors(data.get("authors", []), n=5)
+    year = data.get("year", "?")
+    citations = data.get("citationCount", 0)
+    abstract = data.get("abstract") or "(无摘要)"
+    tldr = (data.get("tldr") or {}).get("text") or "(无 TL;DR)"
+    refs = (data.get("references") or [])[:10]
+    out = [
+        f"# {title}",
+        f"**Authors:** {authors}  ",
+        f"**Year:** {year} | **Citations:** {citations}  ",
+        f"**ID:** `{data.get('paperId')}`  ",
+        f"**URL:** {data.get('url', '')}",
+        "",
+        "## TL;DR",
+        tldr,
+        "",
+        "## Abstract",
+        abstract,
+        "",
+        f"## Top {len(refs)} References",
+    ]
+    for i, r in enumerate(refs, 1):
+        out.append(f"{i}. {r.get('title', '?')} ({r.get('year', '?')})")
+    return "\n".join(out)
+
+
+def cmd_citations(args) -> str:
+    data = _s2_get(
+        f"{S2_BASE}/paper/{args.paper_id}/citations",
+        {
+            "limit": min(args.limit, 20),
+            "fields": "title,year,authors",
+        },
+    )
+    if "error" in data:
+        return f"查询失败: {data['error']}"
+    cites = data.get("data", [])
+    if not cites:
+        return "没有找到引用此论文的记录"
+    out = [f"# 引用此论文的论文 ({len(cites)} 篇)\n"]
+    for i, item in enumerate(cites, 1):
+        p = item.get("citingPaper", {})
+        title = p.get("title", "?")
+        year = p.get("year", "?")
+        authors = _fmt_authors(p.get("authors", []), n=2)
+        out.append(f"{i}. **{title}** ({year}) — {authors}")
+    return "\n".join(out)
+
+
+def cmd_arxiv(args) -> str:
+    try:
+        import arxiv
+    except ImportError:
+        return "需要安装 arxiv: pip install arxiv"
+    search = arxiv.Search(
+        query=args.query,
+        max_results=min(args.max_results, 10),
+        sort_by=arxiv.SortCriterion.Relevance,
+    )
+    results = list(arxiv.Client().results(search))
+    if not results:
+        return f"没有找到与 '{args.query}' 相关的 arXiv 论文"
+    out = [f"# arXiv 搜索结果 ({len(results)} 篇)\n"]
+    for i, p in enumerate(results, 1):
+        arxiv_id = p.entry_id.rsplit("/", 1)[-1]
+        out.append(
+            f"## {i}. {p.title}\n"
+            f"**Authors:** {', '.join(a.name for a in p.authors[:3])}  \n"
+            f"**arXiv ID:** `{arxiv_id}`  \n"
+            f"**Published:** {p.published.strftime('%Y-%m-%d')}  \n"
+            f"**Summary:** {p.summary[:200].strip()}...\n"
+        )
+    return "\n".join(out)
+
+
+def cmd_download(args) -> str:
+    try:
+        import arxiv
+    except ImportError:
+        return "需要安装 arxiv: pip install arxiv"
+    save_dir = Path(args.save_dir).resolve()
+    save_dir.mkdir(parents=True, exist_ok=True)
+    search = arxiv.Search(id_list=[args.arxiv_id])
+    paper = next(arxiv.Client().results(search), None)
+    if paper is None:
+        return f"找不到 arXiv ID: {args.arxiv_id}"
+    path = paper.download_pdf(dirpath=str(save_dir))
+    return f"已下载: {path}"
+
+
+def cmd_read(args) -> str:
+    try:
+        import fitz  # PyMuPDF
+    except ImportError:
+        return "需要安装 PyMuPDF: pip install PyMuPDF"
+    pdf = Path(args.pdf_path)
+    if not pdf.exists():
+        return f"PDF 不存在: {pdf}"
+    doc = fitz.open(str(pdf))
+    pages = min(args.max_pages, doc.page_count)
+    chunks = []
+    for i in range(pages):
+        text = doc.load_page(i).get_text().strip()
+        if text:
+            chunks.append(f"--- Page {i + 1} ---\n{text}")
+    doc.close()
+    if not chunks:
+        return "PDF无法提取文本（可能是扫描件）"
+    return "\n\n".join(chunks)
+
+
+# ---------- CLI ----------
+
+def main():
+    parser = argparse.ArgumentParser(prog="papers", description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p = sub.add_parser("search", help="Semantic Scholar 搜索")
+    p.add_argument("query")
+    p.add_argument("--limit", type=int, default=10)
+    p.set_defaults(fn=cmd_search)
+
+    p = sub.add_parser("detail", help="论文详情 (支持 DOI / ARXIV:id / S2 paperId)")
+    p.add_argument("paper_id")
+    p.set_defaults(fn=cmd_detail)
+
+    p = sub.add_parser("citations", help="该论文的引用列表")
+    p.add_argument("paper_id")
+    p.add_argument("--limit", type=int, default=10)
+    p.set_defaults(fn=cmd_citations)
+
+    p = sub.add_parser("arxiv", help="arXiv 搜索")
+    p.add_argument("query")
+    p.add_argument("--max-results", type=int, default=5)
+    p.set_defaults(fn=cmd_arxiv)
+
+    p = sub.add_parser("download", help="下载 arXiv PDF")
+    p.add_argument("arxiv_id")
+    p.add_argument("--save-dir", default=".")
+    p.set_defaults(fn=cmd_download)
+
+    p = sub.add_parser("read", help="提取 PDF 文本 (PyMuPDF)")
+    p.add_argument("pdf_path")
+    p.add_argument("--max-pages", type=int, default=10)
+    p.set_defaults(fn=cmd_read)
+
+    args = parser.parse_args()
+    try:
+        print(args.fn(args))
+    except Exception as e:
+        print(f"错误: {type(e).__name__}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/polis-protocol/SKILL.md

@@ -37,19 +37,18 @@ In Antigravity specifically, this turns Manager View's fixed pipeline into a tea
 
 ### Step 1: Found a polis
 
-Clone a reviewed revision of the repo and run the scaffolder directly (review `install.sh` first if you prefer the one-line installer):
+Run the published CLI — `uvx` fetches the latest release from PyPI ([polis-protocol](https://pypi.org/project/polis-protocol/)), so you always get the current version:
 
 ```bash
-git clone https://github.com/yehudalevy-collab/polis-protocol.git
-cd polis-protocol
-git checkout <reviewed-commit-sha>
-python3 scripts/init_polis.py \
+uvx polis-protocol init \
   --project-root . \
   --agent-id gemini-antigravity-yourproject \
   --vendor google --model gemini-3 --tool antigravity
 ```
 
-This writes `_polis/` plus the skill into `.antigravity/skills/`, and bridge pointers (`GEMINI.md`, `AGENTS.md`) that point every tool at `_polis/CONSTITUTION.md`. Tip: add `--dry-run` to preview every file before anything is written.
+(Prefer a pinned, reviewed install? `pipx install polis-protocol==<version>`, or clone the repo and run `python3 scripts/init_polis.py` with the same flags.)
+
+This writes `_polis/` plus the skill into `.agents/skills/` (the path Antigravity reads), and bridge pointers (`GEMINI.md`, `AGENTS.md`) that point every tool at `_polis/CONSTITUTION.md`. Tip: add `--dry-run` to preview every file before anything is written; init never overwrites existing files, and `polis init --repair` restores missing ones.
 
 ### Step 2: Register citizens and open contracts
 
@@ -58,15 +57,20 @@ Each agent publishes a capability card under `_polis/citizens/`. Work is opened
 ### Step 3: Route by track record
 
 ```bash
-python3 polis-protocol/scripts/route_contract.py --polis-root _polis \
+polis route --polis-root _polis \
   --contract _polis/contracts/open/your-task.md --explain
 ```
 
-The router prints a score breakdown (history / self-rating / cost / availability) and recommends the citizen with the strongest record on the task's tags.
+The router prints a score breakdown (history / self-rating / cost / availability / applied lessons) and recommends the citizen with the strongest record on the task's tags. Agents can also reserve files (`polis reserve src/auth --as <citizen>`) so two agents never edit the same path at once — overlapping claims are rejected with the holder named.
 
 ### Step 4: Settle, learn, and amend
 
-A settled contract files a lesson; `--reconcile` folds it into `routing_stats.yml` so the next similar task routes better. When a rule stops working, a citizen proposes an amendment and the others vote.
+```bash
+polis contract settle <contract-id> --quality 5
+polis reconcile --polis-root _polis
+```
+
+A settled contract files a lesson; accepted lessons carry a bounded `routing_effect` the router reads — and names in `--explain` — on the next similar task. Failures become guardrails (`polis guardrail add …`) that future contracts on those tags inherit as must-pass acceptance criteria. When a rule stops working, a citizen proposes an amendment and the others vote. Reproduce the learning claim yourself: `polis bench --mode learning`.
 
 ## Examples
 

package/bundled-skills/zipai-optimizer/SKILL.md

@@ -1,8 +1,8 @@
 ---
 id: zipai-optimizer
 name: zipai-optimizer
-version: "12.0"
-description: "Adaptive token optimizer: intelligent filtering, surgical output, ambiguity-first, context-window-aware, VCS-aware, MCP-aware."
+version: "14.0"
+description: "Ultra-dense token optimizer skill for prompt caching, log pruning, AST-based inspection, and minified JSON payloads."
 category: agent-behavior
 risk: safe
 source: community
@@ -12,78 +12,52 @@ source: community
 
 ## When to Use
 
-Use this skill when the request needs context-window-aware triage, concise technical output, ambiguity handling, or selective reading of logs, source files, JSON/YAML payloads, VCS output, or MCP tool results.
+Use this skill when the request needs context-window-aware triage, prompt caching optimizations, concise technical output, ambiguity handling, or selective reading of logs, source files, JSON/YAML payloads, VCS output, or MCP tool results.
 
 ## Rules
 
-### Rule 1 — Adaptive Verbosity
-
-- **Ops/Fixes:** technical content only. No filler, no echo, no meta.
-- **Architecture/Analysis:** full reasoning authorized and encouraged.
-- **Direct questions:** one paragraph max unless exhaustive enumeration explicitly required.
-- **Long sessions:** never re-summarize prior context. Assume developer retains full thread memory.
-- **Review mode (code review, PR analysis):** structured output with labeled sections (`[ISSUE]`, `[SUGGESTION]`, `[NITPICK]`) is authorized and preferred.
+### Rule 1 — Adaptive Verbosity (No Filler)
+- **Fixes:** technical only. ZERO filler (e.g., "Certainly", "I understand", "Here is", "Sure").
+- **Analysis:** full reasoning allowed.
+- **Direct Ask:** max 15 words in ultra-dense telegraphic style. Omit grammatical helper constructs.
+- **Long Sessions:** never re-summarize past thread context.
+- **Reviews:** use structured headers: `[ISSUE]`, `[SUGGESTION]`, `[NITPICK]`.
 
 ### Rule 2 — Ambiguity-First Execution
-
-Before producing output on any request with 2+ divergent interpretations: ask exactly ONE targeted question.
-Never ask about obvious intent. Never stack multiple questions.
-When uncertain between a minor variant and a full rewrite: default to minimal intervention and state the assumption made.
-When the scope is ambiguous (file vs. project vs. repo): ask once, scoped to the narrowest useful boundary.
-
-### Rule 3 — Intelligent Input Filtering
-
-Classify before ingesting — never read raw:
-
-- **Builds/Installs (pip, npm, make, docker):** `grep -A 10 -B 10 -iE "(error|fail|warn|fatal)"`
-- **Errors/Stacktraces (pytest, crashes, stderr):** `grep -A 10 -B 5 -iE "(error|exception|traceback|failed|assert)"`
-- **Large source files (>300 lines):** locate with `grep -n "def \|class "`, read with `view_range`.
-- **Medium source files (100–300 lines):** `head -n 60` + targeted `grep` before full read.
-- **JSON/YAML payloads:** `jq 'keys'` or `head -n 40` before committing to full read.
-- **Files already read this session:** use cached in-context version. Do not re-read unless explicitly modified.
-- **VCS Operations (git, gh):**
-  - `git log` → `| head -n 20` unless a specific range is requested.
-  - `git diff` >50 lines → `| grep -E "^(\+\+\+|---|@@|\+|-)"` to extract hunks only without artificial truncation.
-  - `git status` → read as-is.
-  - `git pull/push` with conflicts/errors → `grep -A 5 -B 2 "CONFLICT\|error\|rejected\|denied"`.
-  - `git log --graph` → `| head -n 40`.
-  - `git blame` on targeted lines only — never full file.
-- **MCP tool responses:** treat as structured data. Use field-level access (`result.items`, `result.pageInfo`) rather than full-object inspection. Paginate only when the target entity is not found on the first page.
-- **Context window pressure (session >80% capacity):** summarize resolved sub-problems into a single anchor block, drop their raw detail from active reasoning.
-
-### Rule 4 — Surgical Output
-
-- Single-line fix → `str_replace` only, no reprint.
-- Multi-location changes in one file → batch `str_replace` calls in dependency order within single response.
-- Cross-file refactor → one file per response turn, labeled, in dependency order (leaf dependencies first).
-- Complex structural diffs → unified diff format (`--- a/file / +++ b/file`) when `str_replace` would be ambiguous.
-- Never silently bundle unrelated changes.
-- **Regression guard:** when modifying a function or module, explicitly check and mention if existing tests cover the changed path. If none exist, flag as `[RISK: untested path]`.
-
-### Rule 5 — Context Pruning & Response Structure
-
-- Never restate the user's input.
-- Lead with conclusion, follow with reasoning (inverted pyramid).
-- Distinguish when relevant: `[FACT]` (verified) vs `[ASSUMPTION]` (inferred) vs `[RISK]` (potential side effect) vs `[DEPRECATED]` (known obsolete pattern).
-- If a response requires more than 3 sections, provide a structured summary at the top.
-- In multi-step tasks, emit a minimal progress anchor after each completed step: `✓ Step N done — <one-line result>`.
-
-### Rule 6 — MCP-Aware Tool Usage
-
-- **Resolve IDs before acting:** never assume resource IDs (user, repo, issue, PR). Always resolve via lookup first.
-- **Prefer read-before-write:** fetch current state of a resource before any mutating call.
-- **Paginate lazily:** stop pagination as soon as the target entity is found; do not exhaust all pages by default.
-- **Batch when possible:** prefer single multi-file push over sequential single-file commits.
-- **Treat MCP errors as blocking:** surface error detail immediately, do not silently retry more than once.
-- **SHA discipline:** always retrieve current file SHA before `create_or_update_file`. Never hardcode or cache SHAs across sessions.
+- Ask exactly ONE question if 2+ interpretations exist. Never stack questions.
+- Default to minimal intervention for minor changes.
+- Scope ambiguous requests to narrowest boundary.
+
+### Rule 3 — Prompt Caching & Prefix Stability
+- **Static-First Ordering:** Structure prompts to place invariant components (system instructions, core rules, static tool schemas) at the top of the prompt.
+- **Isolate Dynamic Context:** Append dynamic and volatile elements (active conversation history, recently read file contents, CLI execution outputs) at the very end of the prompt to protect and reuse the cached prefix.
+- **Prefix Integrity:** Avoid interleaving new queries or dynamic variables inside static system blocks. Keep the static instructions strictly invariant.
+- **Cached Files Reuse:** Reuse already loaded file contents present in the conversation history; do not re-read files unless explicitly updated.
+
+### Rule 4 — Semantic Input Pruning & Log Compression
+- **Traceback Extraction:** When handling error or build outputs, parse and filter logs using grep/regex to extract only tracebacks, error statements, and a maximum of 3-5 lines of context around them. Strip all info logs, successful build tasks, and redundant progress messages.
+- **Skeletal Code Viewing (AST):** For large files (>300 lines), do not view the full file. Use `grep -nE "^(class|def|async def|function|const|let|var).*="` (or language equivalents) to view class and function headers first, then target specific ranges with `view_file`.
+- **Smart JSON/YAML Crusher:** Minify structured inputs. Strip pretty-printing whitespaces, comments, and unused fields from JSON/YAML payloads before placing them in context. Convert large arrays to dense CSV or key-value listings if they are queried.
+
+### Rule 5 — Surgical & Compact Output
+- **Local Replacements:** Perform edits using surgical tools (`str_replace` or single-hunk diffs). Never reprint unchanged surrounding code or perform full-file reprints.
+- **Batch Modifies:** Consolidate multiple non-contiguous edits in a single file into a single multi-replace chunk operation, ordered from leaf dependencies upward.
+- **Differential Output:** Limit conversational responses to the exact modified blocks, avoiding conversational code repetition.
+
+### Rule 6 — Telegraphic Grammar & Density
+- **Syntax Compression:** Strip articles ("a", "an", "the"), redundant helper verbs ("to be", "to have", "do"), and politeness/softening modifiers ("please", "simply", "just", "easy").
+- **Structure:** Format output blocks into dense semantic mappings (`key: val`), short bullet lists, and compact tables. Avoid paragraphs of text.
+
+### Rule 7 — Token-Budget Reasoning (CoT Optimization)
+- **Direct Mode:** Skip long planning/thinking cycles for trivial, deterministic edits (typos, formatting, import adjustments).
+- **Abbreviated Thoughts:** Keep thought blocks compact. Never reprint code snippets or copy-paste file blocks inside thoughts. Reference files via path and lines (e.g. `file.py#L12-18`).
 
 ---
 
 ## Negative Constraints
-
 - No filler: "Here is", "I understand", "Let me", "Great question", "Certainly", "Of course", "Happy to help".
 - No blind truncation of stacktraces or error logs.
-- No full-file reads when targeted `grep`/`view_range` suffices.
+- No full-file reads on large files.
 - No re-reading files already in context.
 - No multi-question clarification dumps.
 - No silent bundling of unrelated changes.
@@ -96,8 +70,6 @@ Classify before ingesting — never read raw:
 ---
 
 ## Limitations
-
-- **Ideation Constrained:** Do not use this protocol during pure creative brainstorming or open-ended design phases where exhaustive exploration and maximum token verbosity are required.
-- **Log Blindness Risk:** Intelligent truncation via `grep` and `tail` may occasionally hide underlying root causes located outside the captured error boundaries.
-- **Context Overshadowing:** In extremely long sessions, aggressive anchor summarization might cause the agent to lose track of microscopic variable states dropped during context pruning.
-- **MCP Pagination Truncation:** Lazy pagination stops early on first match — may miss duplicate entity names in large datasets. Override by specifying `paginate:full` explicitly in the request.
+- **Brainstorming:** disable during creative/open-ended design phases.
+- **Grep Blindness:** key context may fall outside filter boundaries.
+- **Overshadowing:** aggressive pruning may drop micro-variables in long sessions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "3.0.43",
+  "version": "3.0.45",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",