@kortix/sandbox 0.4.1

package/opencode/skills/KORTIX-paper-creator/scripts/compile.sh

@@ -0,0 +1,177 @@
+#!/usr/bin/env bash
+# LaTeX compilation pipeline with error recovery.
+#
+# Usage:
+#   bash compile.sh <path-to-main.tex>
+#   bash compile.sh paper/my-paper/main.tex
+#   bash compile.sh paper/my-paper/main.tex --clean    # remove aux files after
+#
+# Runs: pdflatex -> bibtex -> pdflatex -> pdflatex
+# Exit codes: 0 = success, 1 = error
+
+set -euo pipefail
+
+# --- Args ---
+if [ $# -lt 1 ]; then
+    echo "Usage: compile.sh <path-to-main.tex> [--clean]" >&2
+    exit 1
+fi
+
+TEX_FILE="$1"
+CLEAN=false
+if [[ "${2:-}" == "--clean" ]]; then
+    CLEAN=true
+fi
+
+if [ ! -f "$TEX_FILE" ]; then
+    echo "ERROR: File not found: $TEX_FILE" >&2
+    exit 1
+fi
+
+# --- Paths ---
+TEX_DIR="$(cd "$(dirname "$TEX_FILE")" && pwd)"
+TEX_NAME="$(basename "$TEX_FILE" .tex)"
+BUILD_DIR="$TEX_DIR/build"
+mkdir -p "$BUILD_DIR"
+
+# --- Helper: run pdflatex ---
+run_pdflatex() {
+    local pass_name="$1"
+    echo "=== pdflatex pass: $pass_name ==="
+    # TEXINPUTS adds TEX_DIR as a search path so \input{sections/...} resolves.
+    # Trailing colon means "append default search paths".
+    if TEXINPUTS="$TEX_DIR:" pdflatex \
+        -interaction=nonstopmode \
+        -halt-on-error \
+        -output-directory="$BUILD_DIR" \
+        "$TEX_FILE" > "$BUILD_DIR/pdflatex_${pass_name}.stdout" 2>&1; then
+        echo "  OK"
+        return 0
+    else
+        echo "  FAILED (exit $?)" >&2
+        # Extract error lines from log
+        local LOG="$BUILD_DIR/${TEX_NAME}.log"
+        if [ -f "$LOG" ]; then
+            echo "--- Errors from $LOG ---" >&2
+            grep -n -A2 "^!" "$LOG" | head -40 >&2
+            echo "---" >&2
+        fi
+        return 1
+    fi
+}
+
+# --- Helper: run bibtex ---
+run_bibtex() {
+    echo "=== bibtex ==="
+    # bibtex needs to run in the build dir where the .aux file is
+    pushd "$BUILD_DIR" > /dev/null
+    if bibtex "$TEX_NAME" > bibtex.stdout 2>&1; then
+        echo "  OK"
+        popd > /dev/null
+        return 0
+    else
+        local exit_code=$?
+        # bibtex exit code 1 = warnings (ok), 2 = errors
+        if [ $exit_code -le 1 ]; then
+            echo "  OK (with warnings)"
+            popd > /dev/null
+            return 0
+        else
+            echo "  FAILED (exit $exit_code)" >&2
+            if [ -f "$TEX_NAME.blg" ]; then
+                echo "--- Errors from ${TEX_NAME}.blg ---" >&2
+                grep -i "error" "$TEX_NAME.blg" | head -20 >&2
+                echo "---" >&2
+            fi
+            popd > /dev/null
+            return 1
+        fi
+    fi
+}
+
+# --- Copy .bib file to build dir so bibtex can find it ---
+if [ -f "$TEX_DIR/references.bib" ]; then
+    cp "$TEX_DIR/references.bib" "$BUILD_DIR/"
+fi
+
+# --- Copy figures dir symlink ---
+if [ -d "$TEX_DIR/figures" ] && [ ! -e "$BUILD_DIR/figures" ]; then
+    ln -s "$TEX_DIR/figures" "$BUILD_DIR/figures"
+fi
+
+# --- Copy sections dir symlink ---
+if [ -d "$TEX_DIR/sections" ] && [ ! -e "$BUILD_DIR/sections" ]; then
+    ln -s "$TEX_DIR/sections" "$BUILD_DIR/sections"
+fi
+
+# --- Compilation Pipeline ---
+echo "Compiling: $TEX_FILE"
+echo "Build dir: $BUILD_DIR"
+echo ""
+
+# Pass 1: initial compilation (generates .aux with citation keys)
+if ! run_pdflatex "1-initial"; then
+    echo "COMPILE FAILED on pass 1." >&2
+    exit 1
+fi
+
+# BibTeX: resolve citations (only if there are \citation commands in .aux)
+if [ -f "$BUILD_DIR/references.bib" ] && grep -q '\\citation{' "$BUILD_DIR/${TEX_NAME}.aux" 2>/dev/null; then
+    if ! run_bibtex; then
+        echo "WARNING: bibtex had errors, continuing anyway..." >&2
+    fi
+elif [ -f "$BUILD_DIR/references.bib" ]; then
+    echo "=== bibtex: skipped (no \\citation commands in .aux yet) ==="
+else
+    echo "=== bibtex: skipped (no references.bib) ==="
+fi
+
+# Pass 2: incorporate bibliography
+if ! run_pdflatex "2-bib"; then
+    echo "COMPILE FAILED on pass 2." >&2
+    exit 1
+fi
+
+# Pass 3: resolve cross-references
+if ! run_pdflatex "3-final"; then
+    echo "COMPILE FAILED on pass 3." >&2
+    exit 1
+fi
+
+# --- Check for warnings ---
+LOG="$BUILD_DIR/${TEX_NAME}.log"
+if [ -f "$LOG" ]; then
+    # Match both standard LaTeX and package (natbib, cleveref, etc.) warnings
+    UNDEF_REFS=$(grep -c "Warning: Reference .* undefined" "$LOG" 2>/dev/null || true)
+    UNDEF_CITES=$(grep "Warning: Citation .* undefined" "$LOG" 2>/dev/null | grep -vc "There were" 2>/dev/null || true)
+    OVERFULL=$(grep -c "Overfull" "$LOG" 2>/dev/null || true)
+    UNDERFULL=$(grep -c "Underfull" "$LOG" 2>/dev/null || true)
+
+    echo ""
+    echo "=== Compilation Summary ==="
+    echo "  PDF: $BUILD_DIR/${TEX_NAME}.pdf"
+    echo "  Undefined references: $UNDEF_REFS"
+    echo "  Undefined citations:  $UNDEF_CITES"
+    echo "  Overfull boxes:       $OVERFULL"
+    echo "  Underfull boxes:      $UNDERFULL"
+
+    if [ "$UNDEF_REFS" -gt 0 ] || [ "$UNDEF_CITES" -gt 0 ]; then
+        echo ""
+        echo "  WARNING: Unresolved references/citations detected."
+        grep "Warning: \(Reference\|Citation\)" "$LOG" | grep -v "There were" | head -20
+    fi
+fi
+
+# --- Clean aux files if requested ---
+if $CLEAN; then
+    echo ""
+    echo "Cleaning aux files..."
+    rm -f "$BUILD_DIR"/*.aux "$BUILD_DIR"/*.log "$BUILD_DIR"/*.bbl \
+          "$BUILD_DIR"/*.blg "$BUILD_DIR"/*.out "$BUILD_DIR"/*.toc \
+          "$BUILD_DIR"/*.lof "$BUILD_DIR"/*.lot "$BUILD_DIR"/*.stdout
+    echo "  Done. Only PDF remains."
+fi
+
+echo ""
+echo "BUILD SUCCESSFUL: $BUILD_DIR/${TEX_NAME}.pdf"
+exit 0

package/opencode/skills/KORTIX-paper-creator/scripts/openalex_to_bibtex.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""Convert OpenAlex API JSON response to BibTeX entries.
+
+Usage:
+    # Pipe from curl
+    curl -s "https://api.openalex.org/works?search=topic&per_page=10&mailto=agent@kortix.ai" | python3 openalex_to_bibtex.py
+
+    # From file
+    python3 openalex_to_bibtex.py < results.json
+
+    # Single work object (not a search response)
+    python3 openalex_to_bibtex.py --single < work.json
+
+    # Append to existing .bib file
+    curl -s "..." | python3 openalex_to_bibtex.py >> references.bib
+
+Output: BibTeX entries to stdout, one per work. Diagnostics to stderr.
+"""
+
+import json
+import sys
+import re
+import unicodedata
+
+def normalize_ascii(text):
+    """Normalize unicode to ASCII-safe LaTeX-compatible text."""
+    if not text:
+        return ""
+    # NFKD decomposition, strip combining marks
+    text = unicodedata.normalize("NFKD", text)
+    text = "".join(c for c in text if not unicodedata.combining(c))
+    # Replace common special chars
+    replacements = {
+        "\u2013": "--", "\u2014": "---", "\u2018": "`", "\u2019": "'",
+        "\u201c": "``", "\u201d": "''", "\u00e9": "\\'e", "\u00e8": "\\`e",
+        "\u00f6": '\\"o', "\u00fc": '\\"u', "\u00e4": '\\"a', "\u00f1": "\\~n",
+        "\u00e7": "\\c{c}", "&": "\\&", "%": "\\%", "#": "\\#", "_": "\\_",
+    }
+    for k, v in replacements.items():
+        text = text.replace(k, v)
+    return text
+
+def make_cite_key(work):
+    """Generate a citation key: firstauthorlastname + year + first_content_word."""
+    year = work.get("publication_year", "XXXX") or "XXXX"
+    # Get first author's last name
+    authorships = work.get("authorships", [])
+    if authorships:
+        name = authorships[0].get("author", {}).get("display_name", "unknown")
+        # Take last word as surname (handles "First Last" and "First M. Last")
+        lastname = name.strip().split()[-1].lower() if name else "unknown"
+    else:
+        lastname = "unknown"
+    # Clean surname to alphanumeric
+    lastname = re.sub(r"[^a-z]", "", lastname)
+    # Get first meaningful word from title
+    title = work.get("display_name", "") or ""
+    stop_words = {"a", "an", "the", "on", "in", "of", "for", "and", "to", "with", "from", "by"}
+    words = re.findall(r"[a-z]+", title.lower())
+    content_word = ""
+    for w in words:
+        if w not in stop_words and len(w) > 2:
+            content_word = w
+            break
+    if not content_word and words:
+        content_word = words[0]
+    return f"{lastname}{year}{content_word}"
+
+def format_authors(authorships):
+    """Format OpenAlex authorships to BibTeX author string."""
+    if not authorships:
+        return "Unknown"
+    names = []
+    for a in authorships:
+        name = a.get("author", {}).get("display_name", "")
+        if name:
+            names.append(name)
+    if not names:
+        return "Unknown"
+    return " and ".join(names)
+
+def get_journal_or_venue(work):
+    """Extract journal name or conference venue."""
+    loc = work.get("primary_location", {}) or {}
+    source = loc.get("source", {}) or {}
+    return source.get("display_name", "")
+
+def get_pages(work):
+    """Extract page numbers from biblio field."""
+    biblio = work.get("biblio", {}) or {}
+    first = biblio.get("first_page", "")
+    last = biblio.get("last_page", "")
+    if first and last:
+        return f"{first}--{last}"
+    elif first:
+        return first
+    return ""
+
+def get_volume_issue(work):
+    """Extract volume and number from biblio."""
+    biblio = work.get("biblio", {}) or {}
+    return biblio.get("volume", ""), biblio.get("issue", "")
+
+def work_to_bibtex(work):
+    """Convert a single OpenAlex work object to a BibTeX entry string."""
+    cite_key = make_cite_key(work)
+    title = normalize_ascii(work.get("display_name", "Untitled"))
+    authors = format_authors(work.get("authorships", []))
+    year = work.get("publication_year", "")
+    doi = work.get("doi", "") or ""
+    if doi.startswith("https://doi.org/"):
+        doi = doi[len("https://doi.org/"):]
+    work_type = work.get("type", "article") or "article"
+    journal = normalize_ascii(get_journal_or_venue(work))
+    pages = get_pages(work)
+    volume, number = get_volume_issue(work)
+    oa_url = (work.get("open_access", {}) or {}).get("oa_url", "")
+
+    # Determine BibTeX entry type
+    type_map = {
+        "article": "article",
+        "review": "article",
+        "preprint": "article",
+        "book": "book",
+        "book-chapter": "incollection",
+        "proceedings-article": "inproceedings",
+        "dissertation": "phdthesis",
+        "dataset": "misc",
+    }
+    bib_type = type_map.get(work_type, "article")
+
+    # Build fields
+    fields = []
+    fields.append(f"  title = {{{title}}}")
+    fields.append(f"  author = {{{authors}}}")
+    if year:
+        fields.append(f"  year = {{{year}}}")
+    if journal:
+        if bib_type == "inproceedings":
+            fields.append(f"  booktitle = {{{journal}}}")
+        elif bib_type in ("article",):
+            fields.append(f"  journal = {{{journal}}}")
+        else:
+            fields.append(f"  publisher = {{{journal}}}")
+    if volume:
+        fields.append(f"  volume = {{{volume}}}")
+    if number:
+        fields.append(f"  number = {{{number}}}")
+    if pages:
+        fields.append(f"  pages = {{{pages}}}")
+    if doi:
+        fields.append(f"  doi = {{{doi}}}")
+    if oa_url:
+        fields.append(f"  url = {{{oa_url}}}")
+    if work_type == "preprint":
+        fields.append(f"  note = {{Preprint}}")
+
+    entry = f"@{bib_type}{{{cite_key},\n"
+    entry += ",\n".join(fields)
+    entry += "\n}\n"
+    return cite_key, entry
+
+def reconstruct_abstract(inverted_index):
+    """Reconstruct plaintext abstract from OpenAlex inverted index."""
+    if not inverted_index:
+        return ""
+    max_pos = max(max(positions) for positions in inverted_index.values())
+    words = [""] * (max_pos + 1)
+    for word, positions in inverted_index.items():
+        for pos in positions:
+            words[pos] = word
+    return " ".join(w for w in words if w)
+
+def main():
+    single_mode = "--single" in sys.argv
+
+    try:
+        data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Handle both search responses (with "results" array) and single work objects
+    if single_mode or "results" not in data:
+        works = [data]
+    else:
+        works = data.get("results", [])
+
+    if not works:
+        print("Warning: No works found in input.", file=sys.stderr)
+        sys.exit(0)
+
+    seen_keys = set()
+    count = 0
+    for work in works:
+        cite_key, entry = work_to_bibtex(work)
+        # Deduplicate keys
+        original_key = cite_key
+        suffix = 1
+        while cite_key in seen_keys:
+            suffix += 1
+            cite_key = f"{original_key}{chr(96 + suffix)}"  # a, b, c...
+            entry = entry.replace(f"{{{original_key},", f"{{{cite_key},", 1)
+        seen_keys.add(cite_key)
+        print(entry)
+        count += 1
+
+        # Print abstract as comment if available
+        abstract_idx = work.get("abstract_inverted_index")
+        if abstract_idx:
+            abstract = reconstruct_abstract(abstract_idx)
+            if abstract:
+                # Print as BibTeX comment for reference
+                print(f"% Abstract [{cite_key}]: {abstract[:300]}{'...' if len(abstract) > 300 else ''}")
+                print()
+
+    print(f"% Generated {count} BibTeX entries from OpenAlex", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()