npm - crewly - Versions diffs - 1.20.131 → 1.20.133 - Mend

crewly 1.20.131 → 1.20.133

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (186) hide show

package/config/skills/agent/pdf-tools/execute.test.sh ADDED Viewed

@@ -0,0 +1,218 @@
+#!/bin/bash
+# Tests for pdf-tools — run with: bash execute.test.sh </dev/null
+# Chrome and WeasyPrint are fakes on an isolated PATH; Markdown uses a stub
+# `markdown` module. Reading uses real pypdf when some Python has it
+# (PDF_TOOLS_TEST_PYTHON, then the pdf-tools venv), else pdftotext, else it
+# checks the needsSetup answer. Nothing is installed. Exit 0 on pass.
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+EXEC="$HERE/execute.sh"
+PASS=0; FAIL=0; SKIP=0
+check() {
+  local name="$1"; local got="$2"; local want="$3"
+  if [ "$got" = "$want" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $name"; echo "  want: $want"; echo "  got:  $got"; fi
+}
+contains() {
+  local name="$1"; local hay="$2"; local needle="$3"
+  case "$hay" in *"$needle"*) PASS=$((PASS+1)) ;; *) FAIL=$((FAIL+1)); echo "FAIL: $name"; echo "  missing: $needle"; echo "  in: ${hay:0:400}" ;; esac
+}
+JQ="$(command -v jq)"; BASH_BIN="${TEST_BASH:-$(command -v bash)}"; SYS_PY="$(command -v python3)"
+[ -n "$JQ" ] && [ -n "$SYS_PY" ] || { echo "jq and python3 are required to run these tests"; exit 1; }
+T="$(mktemp -d)"
+trap 'rm -rf "$T"' EXIT
+mkdir -p "$T/bin" "$T/home" "$T/stub/markdown" "$T/docs/img"
+for tool in bash jq python3 mktemp cat rm tail head dirname mkdir sed tr wc sleep kill id awk grep basename cp uname date; do
+  src="$(command -v "$tool" 2>/dev/null)" && ln -sf "$src" "$T/bin/$tool"
+done
+# A real one-page PDF with the text "Hello Crewly PDF".
+cat > "$T/mkpdf.py" <<'PY'
+import sys
+text = sys.argv[2].encode()
+content = b"BT /F1 18 Tf 20 70 Td (" + text + b") Tj ET"
+objs = [
+    b"<< /Type /Catalog /Pages 2 0 R >>",
+    b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+    b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 144] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>",
+    b"<< /Length %d >>\nstream\n" % len(content) + content + b"\nendstream",
+    b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+]
+out = b"%PDF-1.4\n"
+offsets = []
+for i, o in enumerate(objs, 1):
+    offsets.append(len(out))
+    out += b"%d 0 obj\n" % i + o + b"\nendobj\n"
+xref = len(out)
+out += b"xref\n0 %d\n0000000000 65535 f \n" % (len(objs) + 1)
+for off in offsets:
+    out += b"%010d 00000 n \n" % off
+out += b"trailer\n<< /Size %d /Root 1 0 R >>\nstartxref\n%d\n%%%%EOF\n" % (len(objs) + 1, xref)
+open(sys.argv[1], "wb").write(out)
+PY
+"$SYS_PY" "$T/mkpdf.py" "$T/fixture.pdf" "Hello Crewly PDF"
+# Fake Chrome: records its argv, "prints" the fixture to --print-to-pdf.
+cat > "$T/fake-chrome" <<EOF
+#!/bin/bash
+printf '%s\n' "\$@" > "$T/chrome.args"
+for a in "\$@"; do case "\$a" in --print-to-pdf=*) cp "$T/fixture.pdf" "\${a#--print-to-pdf=}" ;; esac; done
+EOF
+chmod 755 "$T/fake-chrome"
+# Chrome that crashes without output.
+printf '#!/bin/bash\nexit 1\n' > "$T/broken-chrome"; chmod 755 "$T/broken-chrome"
+# Stub python-markdown: wraps each line in <p>, enough to prove the pipeline.
+cat > "$T/stub/markdown/__init__.py" <<'PY'
+import html
+def markdown(text, **_kw):
+    return "\n".join("<p>%s</p>" % html.escape(line) for line in text.splitlines() if line.strip())
+PY
+run() {
+  env -i HOME="$T/home" PATH="$T/bin" CREWLY_HOME="$T/home/.crewly" PYTHONPATH="$T/stub" \
+    PDF_TOOLS_CHROME_PATHS="" PDF_TOOLS_CHROME_TIMEOUT_SEC=10 "$@" "$BASH_BIN" "$EXEC" "$JSON" 2>/dev/null </dev/null
+}
+printf '# 季度报告\n\nRevenue grew **12%%**.\n\n![chart](img/c.png)\n' > "$T/docs/report.md"
+printf '<html><head><style>h1{color:red}</style></head><body><h1>Brief</h1></body></html>\n' > "$T/docs/brief.html"
+# 1. Markdown → PDF with (fake) Chrome.
+JSON="{\"action\":\"render\",\"input\":\"$T/docs/report.md\",\"title\":\"Q3 报告\"}"
+OUT=$(run CHROME_BIN="$T/fake-chrome")
+check "md: success" "$(printf '%s' "$OUT" | "$JQ" -r .success)" "true"
+check "md: engine" "$(printf '%s' "$OUT" | "$JQ" -r .engine)" "chrome"
+check "md: default output path" "$(printf '%s' "$OUT" | "$JQ" -r .pdf)" "$T/docs/report.pdf"
+check "md: output is a PDF" "$(head -c 4 "$T/docs/report.pdf")" "%PDF"
+ARGS="$(cat "$T/chrome.args" 2>/dev/null)"
+contains "chrome: headless new" "$ARGS" "--headless=new"
+contains "chrome: no header/footer" "$ARGS" "--no-pdf-header-footer"
+contains "chrome: print target" "$ARGS" "--print-to-pdf=$T/docs/report.pdf"
+case "$ARGS" in *--user-data-dir*) FAIL=$((FAIL+1)); echo "FAIL: chrome: no --user-data-dir (it makes Chrome hang on macOS)";; *) PASS=$((PASS+1));; esac
+HTML_URL="$(tail -n 1 "$T/chrome.args")"
+check "chrome: renders a file:// URL" "${HTML_URL:0:7}" "file://"
+check "md: nothing written next to the markdown" "$(ls -A "$T/docs" | tr '\n' ' ')" "brief.html img report.md report.pdf "
+# The generated HTML (captured by a Chrome that copies it) carries the stylesheet, title and <base>.
+cat > "$T/capture-chrome" <<EOF
+#!/bin/bash
+for a in "\$@"; do case "\$a" in file://*) f="\${a#file://}"; cp "\$(printf '%b' "\${f//%/\\\\x}")" "$T/captured.html" ;; --print-to-pdf=*) cp "$T/fixture.pdf" "\${a#--print-to-pdf=}" ;; esac; done
+EOF
+chmod 755 "$T/capture-chrome"
+OUT=$(run CHROME_BIN="$T/capture-chrome")
+CAP="$(cat "$T/captured.html" 2>/dev/null)"
+contains "md html: CJK font stack" "$CAP" '"PingFang SC"'
+contains "md html: A4 page rule" "$CAP" "size: A4"
+contains "md html: title" "$CAP" "<title>Q3 报告</title>"
+contains "md html: base href to the markdown dir" "$CAP" "<base href=\"file://$T/docs/\">"
+contains "md html: body converted" "$CAP" "<p># 季度报告</p>"
+# Chrome that writes the PDF and then hangs (seen with Chrome 153 on macOS) is
+# stopped once the PDF is complete instead of blocking until the timeout.
+cat > "$T/hanging-chrome" <<EOF
+#!/bin/bash
+for a in "\$@"; do case "\$a" in --print-to-pdf=*) cp "$T/fixture.pdf" "\${a#--print-to-pdf=}" ;; esac; done
+exec sleep 60
+EOF
+chmod 755 "$T/hanging-chrome"
+START=$(date +%s)
+JSON="{\"action\":\"render\",\"input\":\"$T/docs/report.md\",\"output\":\"$T/out/hang.pdf\"}"
+OUT=$(run CHROME_BIN="$T/hanging-chrome")
+ELAPSED=$(( $(date +%s) - START ))
+check "hanging chrome: success" "$(printf '%s' "$OUT" | "$JQ" -r .success)" "true"
+[ "$ELAPSED" -lt 9 ] && OK=yes || OK="no (${ELAPSED}s)"
+check "hanging chrome: stopped after the grace period, not the timeout" "$OK" "yes"
+# 2. Styled HTML is printed as-is (the original file, not a copy).
+JSON="{\"action\":\"render\",\"input\":\"$T/docs/brief.html\",\"output\":\"$T/out/brief.pdf\"}"
+OUT=$(run CHROME_BIN="$T/fake-chrome")
+check "html: success" "$(printf '%s' "$OUT" | "$JQ" -r .success)" "true"
+check "html: printed the original file" "$(tail -n 1 "$T/chrome.args")" "file://$T/docs/brief.html"
+check "html: output dir created" "$(head -c 4 "$T/out/brief.pdf")" "%PDF"
+# 3. addDefaultStyle prepends the stylesheet to a copy.
+JSON="{\"action\":\"render\",\"input\":\"$T/docs/brief.html\",\"output\":\"$T/out/b2.pdf\",\"addDefaultStyle\":true}"
+OUT=$(run CHROME_BIN="$T/capture-chrome")
+CAP="$(cat "$T/captured.html")"
+contains "addDefaultStyle: stylesheet added" "$CAP" '"PingFang SC"'
+contains "addDefaultStyle: document kept" "$CAP" "h1{color:red}"
+# 4. engine=chrome with no Chrome → needsSetup.
+JSON="{\"action\":\"render\",\"input\":\"$T/docs/brief.html\",\"engine\":\"chrome\"}"
+OUT=$(run)
+check "no chrome: needsSetup" "$(printf '%s' "$OUT" | "$JQ" -r .needsSetup)" "true"
+check "no chrome: skill" "$(printf '%s' "$OUT" | "$JQ" -r .skill)" "pdf-tools"
+check "no chrome: missing" "$(printf '%s' "$OUT" | "$JQ" -c .missing)" '["chrome"]'
+# 5. No engine at all → needsSetup naming both engines.
+JSON="{\"action\":\"render\",\"input\":\"$T/docs/brief.html\"}"
+OUT=$(run)
+check "no engine: missing" "$(printf '%s' "$OUT" | "$JQ" -c .missing)" '["chrome","weasyprint-libs"]'
+# 6. Chrome crashes → WeasyPrint fallback (fake weasyprint CLI).
+printf '#!/bin/bash\ncp "%s" "$2"\n' "$T/fixture.pdf" > "$T/bin/weasyprint"; chmod 755 "$T/bin/weasyprint"
+JSON="{\"action\":\"render\",\"input\":\"$T/docs/brief.html\",\"output\":\"$T/out/w.pdf\"}"
+OUT=$(run CHROME_BIN="$T/broken-chrome")
+check "fallback: engine" "$(printf '%s' "$OUT" | "$JQ" -r .engine)" "weasyprint"
+check "fallback: pdf" "$(head -c 4 "$T/out/w.pdf")" "%PDF"
+rm -f "$T/bin/weasyprint"
+# 7. Bad input.
+JSON='{"action":"render"}'
+check "no input: error" "$(run | "$JQ" -r .error)" "input (a .md/.html file) or inputs (a list of .md/.html/.pdf parts) is required"
+JSON='{"action":"explode"}'
+check "unknown action" "$(run | "$JQ" -r .error)" "unknown action: explode (use render, merge, read, info or check)"
+JSON="{\"action\":\"read\",\"input\":\"$T/docs/report.md\"}"
+check "read non-pdf" "$(run | "$JQ" -r .error)" "not a PDF (or empty): $T/docs/report.md"
+# 8. Reading + merging with real pypdf when available.
+PYPDF_PY=""
+for cand in "${PDF_TOOLS_TEST_PYTHON:-}" "${CREWLY_HOME:-$HOME/.crewly}/venv/pdf-tools/bin/python3" "$SYS_PY"; do
+  [ -n "$cand" ] && [ -x "$cand" ] && "$cand" -c "import pypdf" >/dev/null 2>&1 && { PYPDF_PY="$cand"; break; }
+done
+if [ -n "$PYPDF_PY" ]; then
+  JSON="{\"action\":\"read\",\"input\":\"$T/fixture.pdf\"}"
+  OUT=$(run PDF_TOOLS_PYTHON="$PYPDF_PY")
+  check "read: engine" "$(printf '%s' "$OUT" | "$JQ" -r .engine)" "pypdf"
+  check "read: pages" "$(printf '%s' "$OUT" | "$JQ" -r .pages)" "1"
+  contains "read: text" "$(printf '%s' "$OUT" | "$JQ" -r .text)" "Hello Crewly PDF"
+  JSON="{\"action\":\"read\",\"input\":\"$T/fixture.pdf\",\"maxChars\":5,\"textFile\":\"$T/all.txt\"}"
+  OUT=$(run PDF_TOOLS_PYTHON="$PYPDF_PY")
+  check "read: truncated" "$(printf '%s' "$OUT" | "$JQ" -r .truncated)" "true"
+  contains "read: full text on disk" "$(cat "$T/all.txt")" "Hello Crewly PDF"
+  "$SYS_PY" "$T/mkpdf.py" "$T/second.pdf" "Second part"
+  JSON="{\"action\":\"render\",\"inputs\":[\"$T/docs/brief.html\",\"$T/second.pdf\"],\"output\":\"$T/out/merged.pdf\"}"
+  OUT=$(run PDF_TOOLS_PYTHON="$PYPDF_PY" CHROME_BIN="$T/fake-chrome")
+  check "multi-part: success" "$(printf '%s' "$OUT" | "$JQ" -r .success)" "true"
+  check "multi-part: parts" "$(printf '%s' "$OUT" | "$JQ" -r .parts)" "2"
+  JSON="{\"action\":\"info\",\"input\":\"$T/out/merged.pdf\"}"
+  check "multi-part: 2 pages" "$(run PDF_TOOLS_PYTHON="$PYPDF_PY" | "$JQ" -r .pages)" "2"
+  JSON="{\"action\":\"read\",\"input\":\"$T/out/merged.pdf\",\"pages\":\"2\"}"
+  contains "multi-part: order kept" "$(run PDF_TOOLS_PYTHON="$PYPDF_PY" | "$JQ" -r .text)" "Second part"
+else
+  SKIP=$((SKIP+1)); echo "SKIP: pypdf not available (set PDF_TOOLS_TEST_PYTHON) — checking the needsSetup answer instead"
+  JSON="{\"action\":\"merge\",\"inputs\":[\"$T/fixture.pdf\",\"$T/fixture.pdf\"],\"output\":\"$T/out/m.pdf\"}"
+  OUT=$(run)
+  check "merge without pypdf: needsSetup" "$(printf '%s' "$OUT" | "$JQ" -r .needsSetup)" "true"
+fi
+# 9. Reading without pypdf falls back to pdftotext when the machine has it.
+if command -v pdftotext >/dev/null 2>&1; then
+  ln -sf "$(command -v pdftotext)" "$T/bin/pdftotext"
+  JSON="{\"action\":\"read\",\"input\":\"$T/fixture.pdf\"}"
+  OUT=$(run PDF_TOOLS_PYTHON="$SYS_PY")
+  if "$SYS_PY" -c "import pypdf" >/dev/null 2>&1; then EXPECT=pypdf; else EXPECT=pdftotext; fi
+  check "read fallback: engine" "$(printf '%s' "$OUT" | "$JQ" -r .engine)" "$EXPECT"
+  contains "read fallback: text" "$(printf '%s' "$OUT" | "$JQ" -r .text)" "Hello Crewly PDF"
+  rm -f "$T/bin/pdftotext"
+fi
+# 10. check action + the shipped setup block.
+JSON='{"action":"check"}'
+OUT=$(run CHROME_BIN="$T/fake-chrome")
+check "check: canRender" "$(printf '%s' "$OUT" | "$JQ" -r .canRender)" "true"
+check "setup: venv name reuses pdf-tools" "$("$JQ" -r '.setup.steps[] | select(.type=="python") | .venv' "$HERE/skill.json")" "pdf-tools"
+echo "=== Results: $PASS passed, $FAIL failed, $SKIP skipped ==="
+[ "$FAIL" -eq 0 ]

package/config/skills/agent/pdf-tools/instructions.md ADDED Viewed

@@ -0,0 +1,14 @@
+# pdf-tools — agent instructions
+- **Making a document someone will read:** write Markdown (or styled HTML when
+  layout matters), then `render`. Check the result: `info` for the page count,
+  and open or `read` it before sending. Send the file itself (`core/attach-file`),
+  not a path.
+- **Someone sent a PDF:** `read` it (with `pages` for long files, `textFile` to
+  keep all of it) before answering. If the result has a `note` about no text
+  layer, say the PDF is scanned instead of guessing its content.
+- **Several parts** (cover + body + appendix): pass them as `inputs` in order;
+  existing PDFs can be parts too.
+- **`needsSetup: true`** in any result: tell the user in one line that you are
+  installing the PDF tools (about 3 minutes), run
+  `install-skill --id pdf-tools`, and continue when `[SKILL INSTALLED]` arrives.

package/config/skills/agent/pdf-tools/pdf_tools.py ADDED Viewed

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""pdf-tools helper — the Python half of the Crewly `pdf-tools` skill.
+Runs inside the skill's venv ($CREWLY_HOME/venv/pdf-tools). Every command
+prints one JSON object on stdout and exits non-zero on failure.
+Commands:
+  md2html  <in.md> <out.html> [--title T] [--css FILE ...] [--lang zh] [--base URL]
+  weasyprint <in.html> <out.pdf>
+  merge    <out.pdf> <in.pdf> [<in.pdf> ...]
+  read     <in.pdf> [--pages 1-3,5] [--max-chars N] [--text-file OUT.txt]
+  info     <in.pdf>
+Written for Crewly (MIT). Uses pypdf, python-markdown and weasyprint.
+"""
+import argparse
+import html
+import json
+import os
+import shutil
+import subprocess
+import sys
+# Characters of extracted text returned inline before truncating (the rest
+# goes to --text-file when given).
+DEFAULT_MAX_CHARS = 20000
+# Markdown extensions: tables, fenced code, heading ids, sane lists, footnotes.
+MARKDOWN_EXTENSIONS = ["extra", "toc", "sane_lists", "smarty"]
+def emit(obj, code=0):
+    """Print one JSON object and exit."""
+    print(json.dumps(obj, ensure_ascii=False))
+    sys.exit(code)
+def fail(message, **extra):
+    """Print a failure object and exit 1."""
+    emit(dict(success=False, error=message, **extra), 1)
+def cmd_md2html(args):
+    """Convert Markdown to a standalone HTML document with the given stylesheets."""
+    try:
+        import markdown  # noqa: WPS433 — optional dependency, imported on use
+    except ImportError:
+        fail("python-markdown is not installed in the pdf-tools venv", needsSetup=True, skill="pdf-tools", missing=["python-packages"])
+    with open(args.input, encoding="utf-8") as fh:
+        body = markdown.markdown(fh.read(), extensions=MARKDOWN_EXTENSIONS, output_format="html5")
+    styles = []
+    for css in args.css or []:
+        with open(css, encoding="utf-8") as fh:
+            styles.append(fh.read())
+    title = html.escape(args.title or os.path.splitext(os.path.basename(args.input))[0])
+    base = f'<base href="{html.escape(args.base)}">' if args.base else ""
+    doc = (
+        f'<!DOCTYPE html>\n<html lang="{html.escape(args.lang)}"><head><meta charset="utf-8">{base}'
+        f"<title>{title}</title><style>\n" + "\n".join(styles) + "\n</style></head>\n"
+        f'<body><main class="doc">\n{body}\n</main></body></html>\n'
+    )
+    with open(args.output, "w", encoding="utf-8") as fh:
+        fh.write(doc)
+    emit({"success": True, "html": args.output})
+def cmd_weasyprint(args):
+    """Render HTML to PDF with WeasyPrint (the fallback engine)."""
+    try:
+        import weasyprint  # noqa: WPS433
+    except Exception as exc:  # ImportError, or OSError when pango is missing
+        fail(f"weasyprint is not usable: {exc}", needsSetup=True, skill="pdf-tools", missing=["weasyprint-libs"])
+    base = os.path.dirname(os.path.abspath(args.input))
+    weasyprint.HTML(filename=args.input, base_url=base).write_pdf(args.output)
+    emit({"success": True, "pdf": args.output})
+def load_pypdf():
+    """Import pypdf or fail with a needsSetup object."""
+    try:
+        import pypdf  # noqa: WPS433
+        return pypdf
+    except ImportError:
+        return None
+def cmd_merge(args):
+    """Concatenate PDFs in order."""
+    pypdf = load_pypdf()
+    if pypdf is None:
+        fail("pypdf is not installed in the pdf-tools venv", needsSetup=True, skill="pdf-tools", missing=["python-packages"])
+    writer = pypdf.PdfWriter()
+    pages = 0
+    for part in args.inputs:
+        reader = pypdf.PdfReader(part)
+        for page in reader.pages:
+            writer.add_page(page)
+            pages += 1
+    with open(args.output, "wb") as fh:
+        writer.write(fh)
+    emit({"success": True, "pdf": args.output, "pages": pages, "parts": len(args.inputs)})
+def parse_pages(spec, total):
+    """Turn '1-3,5' into zero-based page indexes within range."""
+    if not spec:
+        return list(range(total))
+    wanted = []
+    for chunk in spec.split(","):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        if "-" in chunk:
+            lo, hi = chunk.split("-", 1)
+            start = int(lo) if lo else 1
+            end = int(hi) if hi else total
+            wanted.extend(range(start, end + 1))
+        else:
+            wanted.append(int(chunk))
+    return [p - 1 for p in wanted if 1 <= p <= total]
+def pdftotext_all(path):
+    """Extract text per page with poppler's pdftotext (fallback).
+    pdftotext ends every page with a form feed, so splitting on it gives one
+    entry per page. Returns None when pdftotext is not installed or fails.
+    """
+    exe = shutil.which("pdftotext")
+    if not exe:
+        return None
+    out = subprocess.run(
+        [exe, "-layout", "-enc", "UTF-8", path, "-"],
+        capture_output=True, text=True, check=False, stdin=subprocess.DEVNULL,
+    )
+    if out.returncode != 0:
+        return None
+    pages = out.stdout.split("\f")
+    if pages and not pages[-1].strip():
+        pages = pages[:-1]
+    return pages
+def cmd_read(args):
+    """Extract text from a PDF (pypdf; pdftotext when pypdf finds none)."""
+    pypdf = load_pypdf()
+    engine = None
+    texts = None
+    total = None
+    indexes = []
+    if pypdf is not None:
+        reader = pypdf.PdfReader(args.input)
+        if reader.is_encrypted:
+            try:
+                reader.decrypt("")
+            except Exception:  # noqa: BLE001 — any failure means we cannot read it
+                fail("the PDF is encrypted and needs a password")
+        total = len(reader.pages)
+        indexes = parse_pages(args.pages, total)
+        texts = [(reader.pages[i].extract_text() or "") for i in indexes]
+        engine = "pypdf"
+    if texts is None or not "".join(texts).strip():
+        whole = pdftotext_all(args.input)
+        if whole is not None:
+            total = len(whole)
+            fb_indexes = parse_pages(args.pages, total)
+            fallback = [whole[i] for i in fb_indexes]
+            if texts is None or "".join(fallback).strip():
+                texts, engine, indexes = fallback, "pdftotext", fb_indexes
+    if texts is None:
+        fail("cannot read PDFs yet: neither pypdf nor pdftotext is installed", needsSetup=True, skill="pdf-tools", missing=["python-packages"])
+    full = "\n\n".join(f"--- page {i + 1} ---\n{t.strip()}" for i, t in zip(indexes, texts))
+    result = {
+        "success": True,
+        "engine": engine,
+        "pages": total,
+        "pagesRead": [i + 1 for i in indexes],
+        "chars": len(full),
+    }
+    if not "".join(texts).strip():
+        result["note"] = "No extractable text: the PDF is probably scanned images. Use OCR or read the page images."
+    if args.text_file:
+        with open(args.text_file, "w", encoding="utf-8") as fh:
+            fh.write(full)
+        result["textFile"] = args.text_file
+    if len(full) > args.max_chars:
+        result["text"] = full[: args.max_chars]
+        result["truncated"] = True
+    else:
+        result["text"] = full
+        result["truncated"] = False
+    emit(result)
+def pdf_page_count(path):
+    """Page count via pdfinfo (poppler) when pypdf is unavailable."""
+    exe = shutil.which("pdfinfo")
+    if not exe:
+        return None
+    out = subprocess.run([exe, path], capture_output=True, text=True, check=False, stdin=subprocess.DEVNULL)
+    for line in out.stdout.splitlines():
+        if line.startswith("Pages:"):
+            return int(line.split(":", 1)[1].strip())
+    return None
+def cmd_info(args):
+    """Page count, encryption and document metadata."""
+    pypdf = load_pypdf()
+    if pypdf is None:
+        pages = pdf_page_count(args.input)
+        if pages is None:
+            fail("pypdf is not installed in the pdf-tools venv", needsSetup=True, skill="pdf-tools", missing=["python-packages"])
+        emit({"success": True, "pages": pages, "engine": "pdfinfo"})
+    reader = pypdf.PdfReader(args.input)
+    meta = {}
+    if reader.metadata:
+        for key, value in reader.metadata.items():
+            meta[str(key).lstrip("/")] = str(value)
+    emit({"success": True, "pages": len(reader.pages), "encrypted": reader.is_encrypted, "metadata": meta, "engine": "pypdf"})
+def main():
+    """Parse arguments and dispatch."""
+    parser = argparse.ArgumentParser(prog="pdf_tools.py")
+    sub = parser.add_subparsers(dest="command", required=True)
+    p = sub.add_parser("md2html")
+    p.add_argument("input")
+    p.add_argument("output")
+    p.add_argument("--title")
+    p.add_argument("--css", action="append")
+    p.add_argument("--lang", default="zh")
+    p.add_argument("--base", help="<base href> for relative links (file:// URL of the source directory)")
+    p.set_defaults(func=cmd_md2html)
+    p = sub.add_parser("weasyprint")
+    p.add_argument("input")
+    p.add_argument("output")
+    p.set_defaults(func=cmd_weasyprint)
+    p = sub.add_parser("merge")
+    p.add_argument("output")
+    p.add_argument("inputs", nargs="+")
+    p.set_defaults(func=cmd_merge)
+    p = sub.add_parser("read")
+    p.add_argument("input")
+    p.add_argument("--pages")
+    p.add_argument("--max-chars", type=int, default=DEFAULT_MAX_CHARS)
+    p.add_argument("--text-file")
+    p.set_defaults(func=cmd_read)
+    p = sub.add_parser("info")
+    p.add_argument("input")
+    p.set_defaults(func=cmd_info)
+    args = parser.parse_args()
+    try:
+        args.func(args)
+    except SystemExit:
+        raise
+    except Exception as exc:  # noqa: BLE001 — report every failure as JSON
+        fail(f"{type(exc).__name__}: {exc}")
+if __name__ == "__main__":
+    main()

package/config/skills/agent/pdf-tools/skill.json ADDED Viewed

@@ -0,0 +1,103 @@
+{
+  "id": "pdf-tools",
+  "name": "pdf-tools",
+  "displayName": "PDF Tools (make + read PDFs)",
+  "description": "Make polished PDFs from Markdown or styled HTML (headless Chrome preferred, WeasyPrint fallback, clean CJK-ready default stylesheet), merge several parts into one PDF, and read PDFs a user sends (text extraction with pypdf / pdftotext). Declares its own setup: Python venv with pypdf, markdown and weasyprint, plus optional Chrome and CJK fonts.",
+  "category": "content-creation",
+  "assignableRoles": ["*"],
+  "version": "1.0.0",
+  "author": "Crewly Team",
+  "license": "MIT",
+  "tags": [
+    "pdf",
+    "document",
+    "report",
+    "markdown",
+    "html",
+    "chrome",
+    "weasyprint",
+    "merge",
+    "read-pdf",
+    "extract-text",
+    "pypdf",
+    "cjk",
+    "中文",
+    "文档"
+  ],
+  "triggers": [
+    "make a pdf",
+    "generate pdf",
+    "markdown to pdf",
+    "html to pdf",
+    "merge pdfs",
+    "read this pdf",
+    "extract text from pdf"
+  ],
+  "execution": {
+    "type": "script",
+    "script": { "file": "execute.sh", "interpreter": "bash", "timeoutMs": 300000 }
+  },
+  "setup": {
+    "estimatedMinutes": 3,
+    "steps": [
+      {
+        "id": "jq",
+        "type": "command",
+        "description": "jq — parses the skill's JSON input and output",
+        "check": { "commands": ["jq"] },
+        "install": { "darwin": { "brew": ["jq"] }, "debian": { "apt": ["jq"] } }
+      },
+      {
+        "id": "python3",
+        "type": "command",
+        "description": "Python 3 with venv support",
+        "check": { "shell": "python3 -c 'import venv, ensurepip' >/dev/null 2>&1" },
+        "install": { "darwin": { "brew": ["python"] }, "debian": { "apt": ["python3", "python3-venv"] } },
+        "manualHint": "Install Python 3 (with the venv module) and put python3 on PATH."
+      },
+      {
+        "id": "python-packages",
+        "type": "python",
+        "description": "pypdf (merge/read), markdown and weasyprint in ~/.crewly/venv/pdf-tools",
+        "venv": "pdf-tools",
+        "packages": ["pypdf>=4", "markdown>=3.5", "weasyprint>=60"],
+        "imports": ["pypdf", "markdown"]
+      },
+      {
+        "id": "weasyprint-libs",
+        "type": "command",
+        "optional": true,
+        "description": "Pango for WeasyPrint (the fallback engine when there is no Chrome)",
+        "check": { "shell": "\"$CREWLY_HOME/venv/pdf-tools/bin/python3\" -c 'import weasyprint' >/dev/null 2>&1" },
+        "install": {
+          "darwin": { "brew": ["pango"] },
+          "debian": { "apt": ["libpango-1.0-0", "libpangoft2-1.0-0", "libharfbuzz-subset0"] }
+        }
+      },
+      {
+        "id": "chrome",
+        "type": "command",
+        "optional": true,
+        "description": "Chrome/Chromium — the preferred engine (headless print-to-pdf)",
+        "check": {
+          "commands": ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"],
+          "paths": [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "/Applications/Chromium.app/Contents/MacOS/Chromium"
+          ]
+        },
+        "install": { "debian": { "apt": ["chromium"] } },
+        "manualHint": "Install Google Chrome; until then PDFs are rendered with WeasyPrint."
+      },
+      {
+        "id": "cjk-fonts",
+        "type": "command",
+        "optional": true,
+        "description": "Chinese/Japanese/Korean fonts (Noto CJK) so CJK text is not blank boxes",
+        "check": { "shell": "[ \"$(uname -s)\" = Darwin ] || fc-list :lang=zh 2>/dev/null | grep -q ." },
+        "install": { "debian": { "apt": ["fonts-noto-cjk"] } }
+      }
+    ]
+  }
+}