psyclaw 0.28.1 → 0.28.2

package/vendor/nature-skills/skills/nature-figure/scripts/audit_pdf_text.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Audit text font sizes used by PDF content-stream ``Tf`` operators.
+
+This dependency-free check catches reduced mathtext superscripts/subscripts and
+other glyph runs that can fall below a journal font-size floor even when the
+parent matplotlib ``fontsize`` is compliant. It supports plain and FlateDecode
+content streams, which covers normal matplotlib PDF output.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import zlib
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+
+STREAM_START = re.compile(rb"stream\r?\n")
+TF_OPERATOR = re.compile(
+    rb"/([^\s/<>]+)\s+([-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][-+]?\d+)?)\s+Tf\b"
+)
+
+
+@dataclass(frozen=True)
+class TextRun:
+    stream: int
+    font: str
+    size_pt: float
+
+
+def decoded_streams(data: bytes) -> tuple[list[bytes], list[str]]:
+    streams: list[bytes] = []
+    warnings: list[str] = []
+    cursor = 0
+    stream_number = 0
+    while True:
+        match = STREAM_START.search(data, cursor)
+        if not match:
+            break
+        stream_number += 1
+        end = data.find(b"endstream", match.end())
+        if end < 0:
+            warnings.append(f"stream {stream_number} has no endstream marker")
+            break
+        # Keep the raw stream bytes. zlib accepts PDF's trailing line break,
+        # while stripping could accidentally remove a legitimate compressed
+        # byte that happens to equal CR or LF.
+        payload = data[match.end() : end]
+        header = data[max(0, match.start() - 2048) : match.start()]
+        dictionary_start = header.rfind(b"<<")
+        dictionary = header[dictionary_start:] if dictionary_start >= 0 else header
+        if b"/FlateDecode" in dictionary:
+            try:
+                payload = zlib.decompress(payload)
+            except zlib.error as exc:
+                warnings.append(f"stream {stream_number} FlateDecode failed: {exc}")
+                cursor = end + len(b"endstream")
+                continue
+        elif b"/Filter" in dictionary:
+            warnings.append(f"stream {stream_number} uses an unsupported PDF filter")
+            cursor = end + len(b"endstream")
+            continue
+        streams.append(payload)
+        cursor = end + len(b"endstream")
+    return streams, warnings
+
+
+def audit_pdf(data: bytes, minimum_pt: float = 5.0) -> dict[str, object]:
+    streams, warnings = decoded_streams(data)
+    runs: list[TextRun] = []
+    for stream_index, stream in enumerate(streams, 1):
+        for match in TF_OPERATOR.finditer(stream):
+            try:
+                font = match.group(1).decode("ascii", errors="replace")
+                size = float(match.group(2))
+            except ValueError:
+                continue
+            if size > 0:
+                runs.append(TextRun(stream=stream_index, font=font, size_pt=size))
+    below = [run for run in runs if run.size_pt < minimum_pt]
+    return {
+        "auditable": bool(runs),
+        "minimum_required_pt": minimum_pt,
+        "minimum_found_pt": min((run.size_pt for run in runs), default=None),
+        "text_run_count": len(runs),
+        "below_minimum_count": len(below),
+        "below_minimum": [asdict(run) for run in below],
+        "warnings": warnings,
+    }
+
+
+def render_text(path: Path, result: dict[str, object]) -> str:
+    lines = [
+        "Nature Figure PDF Text Audit",
+        f"pdf: {path}",
+        f"minimum required: {result['minimum_required_pt']:g} pt",
+    ]
+    if not result["auditable"]:
+        lines.append("verdict: NOT AUDITABLE — no supported Tf text operators were found")
+    else:
+        lines.extend(
+            [
+                f"minimum found: {result['minimum_found_pt']:g} pt",
+                f"text runs: {result['text_run_count']}",
+                f"below minimum: {result['below_minimum_count']}",
+                f"verdict: {'FAIL' if result['below_minimum_count'] else 'PASS'}",
+            ]
+        )
+    for run in result["below_minimum"]:
+        lines.append(f"  - stream {run['stream']}: /{run['font']} {run['size_pt']:g} Tf")
+    for warning in result["warnings"]:
+        lines.append(f"warning: {warning}")
+    lines.append("note: Tf scanning does not replace final-size visual inspection or account for every PDF transform")
+    return "\n".join(lines)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("pdf", type=Path, help="exported PDF figure")
+    parser.add_argument("--min-pt", type=float, default=5.0, help="minimum allowed Tf font size in points")
+    parser.add_argument("--json", action="store_true", help="emit machine-readable JSON")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.min_pt <= 0:
+        print("error: --min-pt must be positive", file=sys.stderr)
+        return 2
+    try:
+        data = args.pdf.read_bytes()
+    except OSError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    if not data.startswith(b"%PDF-"):
+        print(f"error: not a PDF file: {args.pdf}", file=sys.stderr)
+        return 2
+    result = audit_pdf(data, minimum_pt=args.min_pt)
+    if args.json:
+        print(json.dumps({"pdf": str(args.pdf), **result}, indent=2, ensure_ascii=False))
+    else:
+        print(render_text(args.pdf, result))
+    if not result["auditable"]:
+        return 2
+    return 1 if result["below_minimum_count"] else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/nature-skills/skills/nature-figure/scripts/figure_safety.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Small numerical/layout safety helpers for Python publication figures."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+
+def interp_monotone(target: Any, xp: Any, fp: Any) -> Any:
+    """Interpolate on a strictly monotone grid without silent direction errors.
+
+    ``numpy.interp`` requires increasing ``xp``. This helper accepts a strictly
+    increasing or decreasing grid, reverses decreasing ``xp`` and ``fp``
+    together, and rejects duplicate/non-monotone coordinates.
+    """
+    xp_array = np.asarray(xp, dtype=float)
+    fp_array = np.asarray(fp, dtype=float)
+    if xp_array.ndim != 1 or fp_array.ndim != 1 or xp_array.size != fp_array.size:
+        raise ValueError("xp and fp must be one-dimensional arrays of equal length")
+    if xp_array.size < 2:
+        raise ValueError("at least two interpolation points are required")
+    if not np.all(np.isfinite(xp_array)) or not np.all(np.isfinite(fp_array)):
+        raise ValueError("xp and fp must contain only finite values")
+    differences = np.diff(xp_array)
+    if np.all(differences > 0):
+        ordered_xp, ordered_fp = xp_array, fp_array
+    elif np.all(differences < 0):
+        ordered_xp, ordered_fp = xp_array[::-1], fp_array[::-1]
+    else:
+        raise ValueError("xp must be strictly monotone; duplicates or direction changes are unsafe")
+    return np.interp(target, ordered_xp, ordered_fp)
+
+
+def label_y_above(values: Any, spread: Any | None = None, pad_fraction: float = 0.04) -> float:
+    """Return a data-driven label y-position above values and optional spread."""
+    centers = np.asarray(values, dtype=float)
+    if centers.size == 0 or not np.all(np.isfinite(centers)):
+        raise ValueError("values must contain at least one finite value")
+    upper = centers if spread is None else centers + np.asarray(spread, dtype=float)
+    if not np.all(np.isfinite(upper)):
+        raise ValueError("spread must contain only finite values")
+    data_min = float(np.min(centers))
+    data_max = float(np.max(upper))
+    scale = max(data_max - data_min, abs(data_max), 1.0)
+    return data_max + max(0.0, pad_fraction) * scale
+
+
+__all__ = ["interp_monotone", "label_y_above"]

package/vendor/nature-skills/skills/nature-figure/scripts/generate_openrouter_schematic.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Generate manuscript schematic drafts with OpenRouter's Images API."""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import mimetypes
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+API_URL = "https://openrouter.ai/api/v1/images"
+DEFAULT_MODEL = "openai/gpt-image-2"
+
+
+def read_optional_text(text: str | None, path: str | None) -> str:
+    parts: list[str] = []
+    if text:
+        parts.append(text.strip())
+    if path:
+        parts.append(Path(path).read_text(encoding="utf-8").strip())
+    return "\n\n".join(part for part in parts if part)
+
+
+def build_prompt(args: argparse.Namespace) -> str:
+    custom_prompt = read_optional_text(args.prompt, args.prompt_file)
+    if custom_prompt and args.raw:
+        return custom_prompt
+
+    title = args.title.strip() if args.title else ""
+    abstract = read_optional_text(args.abstract, args.abstract_file)
+    panel_map = args.panel_map.strip() if args.panel_map else ""
+
+    content_blocks = []
+    if title:
+        content_blocks.append(f"Title: {title}")
+    if abstract:
+        content_blocks.append(f"Article summary:\n{abstract}")
+    if panel_map:
+        content_blocks.append(f"Desired panel flow:\n{panel_map}")
+    if custom_prompt:
+        content_blocks.append(f"Additional instructions:\n{custom_prompt}")
+
+    if not content_blocks:
+        raise SystemExit(
+            "Provide --prompt/--prompt-file or at least one of --title, "
+            "--abstract/--abstract-file, or --panel-map."
+        )
+
+    style = args.style or (
+        "Create a clean Nature-style scientific graphical abstract / mechanism "
+        "schematic for a research paper. Use a flat vector-like visual language, "
+        "restrained journal palette, clear hierarchy, simple arrows, and minimal "
+        "short labels. Keep the background uncluttered."
+    )
+
+    constraints = (
+        "Scientific constraints: show only the mechanisms and entities described "
+        "below; do not invent quantitative values, p-values, microscopy results, "
+        "institutional logos, journal marks, or unsupported experimental claims. "
+        "Use conceptual visual elements rather than fake data panels. Text labels "
+        "must be short and easy to redraw later."
+    )
+
+    return "\n\n".join([style, constraints, *content_blocks])
+
+
+def reference_to_payload(value: str) -> dict[str, Any]:
+    if value.startswith(("http://", "https://", "data:")):
+        url = value
+    else:
+        path = Path(value)
+        if not path.exists():
+            raise SystemExit(f"Reference image not found: {value}")
+        media_type = mimetypes.guess_type(path.name)[0] or "image/png"
+        encoded = base64.b64encode(path.read_bytes()).decode("ascii")
+        url = f"data:{media_type};base64,{encoded}"
+    return {"type": "image_url", "image_url": {"url": url}}
+
+
+def build_payload(args: argparse.Namespace) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "model": args.model,
+        "prompt": build_prompt(args),
+    }
+
+    optional_fields = {
+        "aspect_ratio": args.aspect_ratio,
+        "resolution": args.resolution,
+        "quality": args.quality,
+        "output_format": args.output_format,
+        "background": args.background,
+        "size": args.size,
+        "n": args.n,
+    }
+    for key, value in optional_fields.items():
+        if value is not None:
+            payload[key] = value
+
+    if args.reference_image:
+        payload["input_references"] = [
+            reference_to_payload(value) for value in args.reference_image
+        ]
+
+    return payload
+
+
+def media_extension(media_type: str | None, output_format: str | None) -> str:
+    if media_type == "image/svg+xml":
+        return ".svg"
+    if media_type == "image/jpeg":
+        return ".jpg"
+    if media_type == "image/webp":
+        return ".webp"
+    if media_type == "image/png":
+        return ".png"
+    if output_format == "jpeg":
+        return ".jpg"
+    if output_format in {"png", "webp"}:
+        return f".{output_format}"
+    return ".png"
+
+
+def decode_b64_image(value: str) -> bytes:
+    if value.startswith("data:"):
+        value = value.split(",", 1)[1]
+    return base64.b64decode(value)
+
+
+def request_images(payload: dict[str, Any], args: argparse.Namespace) -> dict[str, Any]:
+    api_key = os.environ.get(args.api_key_env)
+    if not api_key:
+        raise SystemExit(f"Missing API key: set {args.api_key_env}.")
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    site_url = args.site_url or os.environ.get("OPENROUTER_SITE_URL")
+    app_name = args.app_name or os.environ.get("OPENROUTER_APP_NAME")
+    if site_url:
+        headers["HTTP-Referer"] = site_url
+    if app_name:
+        headers["X-Title"] = app_name
+
+    request = urllib.request.Request(
+        args.api_url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers=headers,
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=args.timeout) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise SystemExit(f"Image request failed ({exc.code}) at {args.api_url}: {body}") from exc
+    except urllib.error.URLError as exc:
+        raise SystemExit(f"Image request failed at {args.api_url}: {exc}") from exc
+
+
+def save_outputs(response: dict[str, Any], payload: dict[str, Any], args: argparse.Namespace) -> None:
+    outdir = Path(args.outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+    basename = args.basename or time.strftime("openrouter_schematic_%Y%m%d_%H%M%S")
+
+    saved: list[str] = []
+    for index, item in enumerate(response.get("data", []), start=1):
+        media_type = item.get("media_type")
+        ext = media_extension(media_type, args.output_format)
+        suffix = "" if len(response.get("data", [])) == 1 else f"_{index:02d}"
+        outpath = outdir / f"{basename}{suffix}{ext}"
+
+        if "b64_json" in item:
+            outpath.write_bytes(decode_b64_image(item["b64_json"]))
+            saved.append(str(outpath))
+        elif "url" in item:
+            with urllib.request.urlopen(item["url"], timeout=args.timeout) as image_response:
+                outpath.write_bytes(image_response.read())
+            saved.append(str(outpath))
+        else:
+            raise SystemExit(f"No image bytes or URL in response item {index}: {item}")
+
+    metadata = {
+        "api_url": args.api_url,
+        "request": payload,
+        "response_usage": response.get("usage"),
+        "created": response.get("created"),
+        "saved_files": saved,
+    }
+    metadata_path = outdir / f"{basename}_request_metadata.json"
+    metadata_path.write_text(json.dumps(metadata, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    print("Saved:")
+    for path in saved:
+        print(f"  {path}")
+    print(f"  {metadata_path}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Generate manuscript schematic drafts with OpenRouter's Images API."
+    )
+    parser.add_argument("--model", default=os.environ.get("OPENROUTER_IMAGE_MODEL", DEFAULT_MODEL))
+    parser.add_argument("--title")
+    parser.add_argument("--abstract")
+    parser.add_argument("--abstract-file")
+    parser.add_argument("--panel-map")
+    parser.add_argument("--prompt")
+    parser.add_argument("--prompt-file")
+    parser.add_argument("--style")
+    parser.add_argument("--raw", action="store_true", help="Use prompt text without the schematic scaffold.")
+    parser.add_argument("--reference-image", action="append", help="Path, URL, or data URL for image-to-image guidance.")
+    parser.add_argument("--outdir", default="openrouter_schematic")
+    parser.add_argument("--basename")
+    parser.add_argument("--aspect-ratio", default="16:9")
+    parser.add_argument("--resolution", default="2K")
+    parser.add_argument("--size", help="Optional OpenRouter size shorthand, such as 2048x2048.")
+    parser.add_argument("--quality", default="high", choices=["auto", "low", "medium", "high"])
+    parser.add_argument("--output-format", default="png", choices=["png", "jpeg", "webp"])
+    parser.add_argument("--background", choices=["auto", "transparent", "opaque"])
+    parser.add_argument("--n", type=int, default=1)
+    parser.add_argument("--api-key-env", default="OPENROUTER_API_KEY")
+    parser.add_argument(
+        "--api-url",
+        default=os.environ.get("SCHEMATIC_IMAGE_API_URL", API_URL),
+        help=(
+            "Images endpoint to call. Defaults to OpenRouter; point it at any "
+            "OpenAI-compatible images endpoint to use that service instead."
+        ),
+    )
+    parser.add_argument("--site-url")
+    parser.add_argument("--app-name")
+    parser.add_argument("--timeout", type=int, default=180)
+    parser.add_argument("--dry-run", action="store_true", help="Print request payload without calling the API.")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    payload = build_payload(args)
+
+    if args.dry_run:
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+        return 0
+
+    response = request_images(payload, args)
+    save_outputs(response, payload, args)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/nature-skills/skills/nature-figure/scripts/nature_figure_backend.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Read or write the user's default nature-figure plotting backend."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+
+VALID_BACKENDS = {"python", "r"}
+
+
+def config_path() -> Path:
+    override = os.environ.get("NATURE_FIGURE_CONFIG")
+    if override:
+        return Path(override).expanduser()
+    return Path("~/.config/nature-skills/nature-figure.json").expanduser()
+
+
+def read_config(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise SystemExit(f"Invalid nature-figure config JSON at {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise SystemExit(f"Invalid nature-figure config at {path}: expected object")
+    return data
+
+
+def write_config(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def get_backend(path: Path) -> int:
+    backend = read_config(path).get("backend")
+    if backend in VALID_BACKENDS:
+        print(backend)
+        return 0
+    return 1
+
+
+def set_backend(path: Path, backend: str) -> int:
+    backend = backend.lower()
+    if backend not in VALID_BACKENDS:
+        raise SystemExit("backend must be one of: python, r")
+    data = read_config(path)
+    data["backend"] = backend
+    write_config(path, data)
+    print(backend)
+    return 0
+
+
+def clear_backend(path: Path) -> int:
+    data = read_config(path)
+    data.pop("backend", None)
+    write_config(path, data)
+    return 0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers.add_parser("get", help="Print the saved backend; exit 1 if unset.")
+    set_parser = subparsers.add_parser("set", help="Save the default backend.")
+    set_parser.add_argument("backend", choices=sorted(VALID_BACKENDS))
+    subparsers.add_parser("clear", help="Remove the saved backend preference.")
+    subparsers.add_parser("path", help="Print the config path.")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    path = config_path()
+    if args.command == "get":
+        return get_backend(path)
+    if args.command == "set":
+        return set_backend(path, args.backend)
+    if args.command == "clear":
+        return clear_backend(path)
+    if args.command == "path":
+        print(path)
+        return 0
+    raise AssertionError(args.command)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())