dsh-aris-panel 0.1.0

package/tools/arxiv_fetch.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""CLI helper for searching and downloading arXiv papers.
+
+Used by the ``arxiv`` skill (skills/arxiv/SKILL.md).
+
+Commands
+--------
+search    Search arXiv and print results as JSON.
+download  Download a paper PDF by arXiv ID.
+
+Examples
+--------
+python3 tools/arxiv_fetch.py search "attention mechanism" --max 10
+python3 tools/arxiv_fetch.py search "id:2301.07041" --max 1
+python3 tools/arxiv_fetch.py download 2301.07041 --dir papers
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+_ATOM_NS = "http://www.w3.org/2005/Atom"
+_API_BASE = "http://export.arxiv.org/api/query"
+_MIN_PDF_BYTES = 10_240
+
+
+def _validate_pdf(size_bytes: int, first_bytes: bytes) -> None:
+    """Reject truncated downloads and non-PDF response bodies."""
+    if size_bytes < _MIN_PDF_BYTES:
+        raise ValueError(
+            f"Downloaded file is only {size_bytes} bytes - likely an error page, not a PDF"
+        )
+    if b"%PDF-" not in first_bytes[:1024]:
+        raise ValueError("Downloaded file has no PDF header - likely an error page, not a PDF")
+
+
+def _arxiv_user_agent() -> str:
+    """Descriptive User-Agent for arXiv API calls.
+
+    arXiv rate-limits the default ``Python-urllib/x.y`` agent far more
+    aggressively than a named client; sending a descriptive UA (with an
+    optional contact address) lands requests in arXiv's more lenient pool.
+    The contact is read from ``ARIS_VERIFY_EMAIL`` — the same env var
+    ``tools/research_wiki.py`` and ``tools/verify_papers.py`` already use —
+    so no address is hard-coded. Falls back to a contactless UA when unset.
+    """
+    contact = os.environ.get("ARIS_VERIFY_EMAIL", "").strip()
+    base = ("arxiv-skill/1.0 "
+            "(+https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep)")
+    return f"{base} (mailto:{contact})" if contact else base
+
+
+_NEW_STYLE_ID_RE = re.compile(r"^\d{4}\.\d{4,5}(v\d+)?$")
+_OLD_STYLE_ID_RE = re.compile(r"^[A-Za-z.-]+/\d{7}(v\d+)?$")
+
+
+def _normalize_id(arxiv_id: str) -> str:
+    """Strip URL/version noise and return a clean arXiv ID."""
+    value = arxiv_id.strip()
+    if "/abs/" in value:
+        value = value.split("/abs/", 1)[1]
+    if value.startswith("id:"):
+        value = value[3:]
+    if "v" in value.split(".")[-1]:
+        value = value.rsplit("v", 1)[0]
+    return value
+
+
+def _looks_like_arxiv_id(value: str) -> bool:
+    """Return True when the input resembles a modern or legacy arXiv ID."""
+    value = value.strip()
+    return bool(_NEW_STYLE_ID_RE.match(value) or _OLD_STYLE_ID_RE.match(value))
+
+
+def _api_url(query: str, max_results: int, start: int) -> str:
+    """Build the arXiv API URL for a search query or specific ID lookup."""
+    query = query.strip()
+    if query.startswith("id:"):
+        params = {"id_list": _normalize_id(query)}
+    elif _looks_like_arxiv_id(query):
+        params = {"id_list": _normalize_id(query)}
+    else:
+        params = {
+            "search_query": query,
+            "start": start,
+            "max_results": max_results,
+            "sortBy": "relevance",
+            "sortOrder": "descending",
+        }
+    return f"{_API_BASE}?{urllib.parse.urlencode(params)}"
+
+
+def _fetch_atom(url: str) -> ET.Element:
+    """Fetch an arXiv Atom feed and return the parsed XML root.
+
+    Sends a descriptive User-Agent (landing requests in arXiv's lenient pool)
+    and retries up to 3 times on HTTP 429, transient network errors, and the
+    plain-text ``Rate exceeded.`` body the API sometimes returns with 200 OK.
+    Raises RuntimeError when all retries are exhausted.
+    """
+    req = urllib.request.Request(url, headers={"User-Agent": _arxiv_user_agent()})
+    for attempt in (1, 2, 3):
+        try:
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                body = resp.read()
+        except urllib.error.HTTPError as e:
+            if e.code == 429 and attempt < 3:
+                time.sleep(5 * attempt)
+                continue
+            raise RuntimeError(f"arXiv API fetch failed: {e}")
+        except (urllib.error.URLError, TimeoutError, OSError) as e:
+            if attempt < 3:
+                time.sleep(2 * attempt)
+                continue
+            raise RuntimeError(f"arXiv API fetch failed: {e}")
+        if body.strip() == b"Rate exceeded.":
+            if attempt < 3:
+                time.sleep(5 * attempt)
+                continue
+            raise RuntimeError("arXiv API rate-limited after 3 attempts")
+        return ET.fromstring(body)
+    # unreachable; loop either returns or raises
+    raise RuntimeError("arXiv API fetch failed: exhausted retries")
+
+
+def _parse_entry(entry: ET.Element) -> dict:
+    """Extract structured fields from a single Atom <entry> element."""
+    raw_id = entry.findtext(f"{{{_ATOM_NS}}}id", "")
+    arxiv_id = _normalize_id(raw_id)
+    title = (entry.findtext(f"{{{_ATOM_NS}}}title", "") or "").strip().replace("\n", " ")
+    abstract = (entry.findtext(f"{{{_ATOM_NS}}}summary", "") or "").strip().replace("\n", " ")
+    published = (entry.findtext(f"{{{_ATOM_NS}}}published", "") or "")[:10]
+    updated = (entry.findtext(f"{{{_ATOM_NS}}}updated", "") or "")[:10]
+    authors = [
+        author.findtext(f"{{{_ATOM_NS}}}name", "")
+        for author in entry.findall(f"{{{_ATOM_NS}}}author")
+    ]
+    categories = [
+        category.get("term", "")
+        for category in entry.findall(f"{{{_ATOM_NS}}}category")
+        if category.get("term")
+    ]
+    return {
+        "id": arxiv_id,
+        "title": title,
+        "authors": authors,
+        "abstract": abstract,
+        "published": published,
+        "updated": updated,
+        "categories": categories,
+        "pdf_url": f"https://arxiv.org/pdf/{arxiv_id}.pdf",
+        "abs_url": f"https://arxiv.org/abs/{arxiv_id}",
+    }
+
+
+def search(query: str, max_results: int = 10, start: int = 0) -> list[dict]:
+    """Search arXiv and return a list of paper dictionaries."""
+    url = _api_url(query, max_results=max_results, start=start)
+    root = _fetch_atom(url)
+    return [_parse_entry(entry) for entry in root.findall(f"{{{_ATOM_NS}}}entry")]
+
+
+def download(arxiv_id: str, output_dir: str = "papers") -> dict:
+    """Download a paper PDF and return metadata about the saved file."""
+    clean_id = _normalize_id(arxiv_id)
+    safe_id = clean_id.replace("/", "_")
+
+    dest_dir = Path(output_dir)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / f"{safe_id}.pdf"
+
+    if dest.exists():
+        size_bytes = dest.stat().st_size
+        with dest.open("rb") as cached_file:
+            first_bytes = cached_file.read(1024)
+        try:
+            _validate_pdf(size_bytes, first_bytes)
+        except ValueError:
+            # Poisoned cache entry (e.g. an HTML error page saved as .pdf by an
+            # older version): drop it so the next call re-downloads instead of
+            # failing forever.
+            dest.unlink()
+            raise
+        return {
+            "id": clean_id,
+            "path": str(dest),
+            "size_kb": size_bytes // 1024,
+            "skipped": True,
+        }
+
+    pdf_url = f"https://arxiv.org/pdf/{clean_id}.pdf"
+    req = urllib.request.Request(pdf_url, headers={"User-Agent": _arxiv_user_agent()})
+
+    data = b""
+    for attempt in (1, 2, 3):
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                data = resp.read()
+            break
+        except urllib.error.HTTPError as exc:
+            if exc.code == 429 and attempt < 3:
+                time.sleep(5 * attempt)
+                continue
+            raise
+        except (urllib.error.URLError, TimeoutError, OSError) as exc:
+            if attempt < 3:
+                time.sleep(2 * attempt)
+                continue
+            raise RuntimeError(f"Failed to download {pdf_url}: {exc}")
+    else:
+        raise RuntimeError(f"Failed to download {pdf_url} after 3 attempts")
+
+    _validate_pdf(len(data), data)
+
+    dest.write_bytes(data)
+    return {
+        "id": clean_id,
+        "path": str(dest),
+        "size_kb": len(data) // 1024,
+        "skipped": False,
+    }
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Search and download arXiv papers.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    def _add_search_args(p: argparse.ArgumentParser) -> None:
+        p.add_argument(
+            "query",
+            help="Search query or arXiv ID (bare ID or id:ARXIV_ID).",
+        )
+        p.add_argument(
+            "--max",
+            type=int,
+            default=10,
+            metavar="N",
+            help="Maximum number of results (default: 10).",
+        )
+        p.add_argument(
+            "--start",
+            type=int,
+            default=0,
+            help="Start offset for pagination (default: 0).",
+        )
+
+    search_parser = subparsers.add_parser("search", help="Search arXiv papers")
+    _add_search_args(search_parser)
+
+    # Defensive aliases — models frequently hallucinate `get` / `fetch`
+    # instead of `search`.  Accept them silently so the invocation succeeds
+    # regardless of model quality.
+    for alias in ("get", "fetch"):
+        _add_search_args(subparsers.add_parser(alias, help="Alias for search"))
+
+    download_parser = subparsers.add_parser("download", help="Download a paper PDF by arXiv ID")
+    download_parser.add_argument(
+        "id",
+        help="arXiv paper ID, e.g. 2301.07041 or cs/0601001",
+    )
+    download_parser.add_argument(
+        "--dir",
+        default="papers",
+        metavar="DIR",
+        help="Output directory (default: papers).",
+    )
+    download_parser.add_argument(
+        "--delay",
+        type=float,
+        default=1.0,
+        help="Seconds to sleep after download (default: 1.0).",
+    )
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _build_parser().parse_args(argv)
+
+    if args.command in ("search", "get", "fetch"):
+        results = search(args.query, max_results=args.max, start=args.start)
+        print(json.dumps(results, ensure_ascii=False, indent=2))
+        return 0
+
+    if args.command == "download":
+        result = download(args.id, output_dir=args.dir)
+        if result.get("skipped"):
+            print(json.dumps({**result, "message": "already exists, skipped"}, ensure_ascii=False))
+        else:
+            time.sleep(args.delay)
+            print(json.dumps(result, ensure_ascii=False))
+        return 0
+
+    raise ValueError(f"Unsupported command: {args.command}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/capture_filter.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Anti-self-poisoning capture filter for ARIS memory (research-wiki / meta-optimize).
+
+When ARIS captures durable knowledge — a research-wiki idea/claim, a meta-optimize
+SKILL.md proposal — it must NOT store *operational noise* that hardens into a
+self-cited falsehood. Hermes learned this the hard way: its self-improvement loop
+poisoned itself with negative tool-capability claims that "harden into refusals
+the agent cites against itself for months after the actual problem was fixed"
+(background_review.py). ARIS's research-wiki "failed ideas → anti-repeat memory"
+is the GOOD inverse; this filter is the missing blocklist for the BAD kind.
+
+This is a CHEAP, DETERMINISTIC pre-filter for the UNAMBIGUOUS classes — error
+output and explicitly-broken-tool phrasing. The judgment-y classes (a single-run
+narrative that isn't a class-level rule; an intentional one-off) are prose
+guidance in shared-references/capture-antipatterns.md, not regex.
+
+Asymmetry (acceptance-gate.md): this filter may REJECT a capture same-model (it
+is a mechanical safety screen, low risk) — but anything that PASSES and would
+become a load-bearing skill/claim still goes to the cross-model jury. Same-model
+is fine to reject; must-be-cross-model to accept.
+
+Deliberately conservative — anchored so it does NOT flag legitimate RESEARCH
+findings ("the model can't generalize to OOD", "the method fails on long
+sequences"). It targets ARIS's OWN TOOLING being declared broken, and raw error
+output. False negatives are fine (the jury still judges); a false reject just
+sends a real insight to manual review.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from typing import List
+
+# Raw error / environment-failure output — unambiguous; these are transient
+# operational state, never a durable research fact.
+_ENV_FAILURE = [
+    (re.compile(r"\bcommand not found\b", re.I), "env_failure"),
+    (re.compile(r"\bNo such file or directory\b", re.I), "env_failure"),
+    (re.compile(r"\bNo module named\b", re.I), "env_failure"),
+    (re.compile(r"\bModuleNotFoundError\b"), "env_failure"),
+    (re.compile(r"\bImportError\b"), "env_failure"),
+    (re.compile(r"\bPermission denied\b", re.I), "env_failure"),
+    (re.compile(r"\bconnection (refused|timed out|reset)\b", re.I), "transient_error"),
+    (re.compile(r"\b(rate limit|429|quota exceeded|503|502|temporarily unavailable)\b", re.I), "transient_error"),
+    (re.compile(r"\bCUDA out of memory\b|\bOOM\b", re.I), "transient_error"),
+]
+
+# Negative tool-capability claims about ARIS's OWN infrastructure. Anchored on
+# ARIS-INFRA-QUALIFIED nouns ONLY — bare model names (codex/gemini/oracle/gpt-5)
+# and generic infra words (the api/server/gpu/tool/cli/reviewer) are deliberately
+# NOT here, because they appear in legitimate research findings ("Gemini cannot
+# solve task T", "the GPU cannot fit the batch", "the API does not expose
+# gradients"). Flagging those would suppress real research notes — the failure
+# this filter must avoid. So we require a qualifier (mcp/cli/reviewer/-pro/-review)
+# or an unambiguous ARIS tool name.
+_TOOL = (r"(?:"
+         r"codex[ -](?:mcp|cli|reviewer)|"
+         r"oracle[ -](?:mcp|pro|reviewer)|"
+         r"gemini[ -](?:mcp|cli|review|reviewer)|"
+         r"manual[ -]review|"
+         # "claude code" dropped — too broad: research notes may benchmark Claude
+         # Code as a coding agent ("Claude Code cannot solve this SWE-bench task"),
+         # which is a finding, not an ARIS-infra complaint.
+         r"mcp server|reviewer mcp|the reviewer backend|"
+         r"wandb"
+         r")")
+_NEG_CLAIM = [
+    (re.compile(_TOOL + r"\s+(?:can'?t|cannot|is unable to|does(?:n'?t| not))\s+", re.I), "negative_tool_claim"),
+    (re.compile(_TOOL + r"\s+(?:is|are|was|were)\s+(?:broken|down|useless|unusable|buggy)\b", re.I), "negative_tool_claim"),
+    (re.compile(_TOOL + r"\s+always\s+(?:fails|crashes|hangs|errors)\b", re.I), "negative_tool_claim"),
+    (re.compile(r"\b(?:don'?t|do not|never)\s+use\s+(?:the\s+|a\s+)?" + _TOOL, re.I), "negative_tool_claim"),
+]
+
+_ALL = _ENV_FAILURE + _NEG_CLAIM
+
+
+def screen(text: str) -> List[str]:
+    """Return de-duplicated anti-pattern reason codes found in `text` (empty = clean).
+
+    reason ∈ {env_failure, transient_error, negative_tool_claim}.
+    """
+    if not text:
+        return []
+    found: List[str] = []
+    for rx, reason in _ALL:
+        if reason not in found and rx.search(text):
+            found.append(reason)
+    return found
+
+
+def reason_detail(reason: str) -> str:
+    return {
+        "env_failure": "looks like an environment-specific failure (missing binary/module/path "
+                       "/permission) — transient state, not a durable fact. Store HOW TO FIX or "
+                       "the missing config, never 'X failed'.",
+        "transient_error": "looks like a transient error (rate limit / OOM / network) that "
+                           "self-resolves — do not capture it as a durable rule.",
+        "negative_tool_claim": "looks like a negative capability claim about ARIS's own tooling "
+                              "('X can't / is broken'). These harden into self-cited refusals long "
+                              "after the real problem is fixed. Store the fix / the workaround, not "
+                              "'X can't do Y'.",
+    }.get(reason, reason)
+
+
+__all__ = ["screen", "reason_detail"]
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="ARIS anti-self-poisoning capture filter.")
+    ap.add_argument("path", help="file to screen, or - for stdin")
+    a = ap.parse_args()
+    text = sys.stdin.read() if a.path == "-" else open(a.path, encoding="utf-8").read()
+    reasons = screen(text)
+    if reasons:
+        print(f"DO-NOT-CAPTURE: {', '.join(reasons)}", file=sys.stderr)
+        for r in reasons:
+            print(f"  - {r}: {reason_detail(r)}", file=sys.stderr)
+        return 1
+    print("ok to capture (mechanical screen clean)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())