opencode-skills-collection 3.1.5 → 3.1.7

package/bundled-skills/hugging-face-model-trainer/scripts/convert_to_gguf.py

@@ -132,6 +132,7 @@ ADAPTER_MODEL = require_hf_id(os.environ.get("ADAPTER_MODEL", "evalstate/qwen-ca
 BASE_MODEL = require_hf_id(os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-0.5B"), "BASE_MODEL")
 OUTPUT_REPO = require_hf_id(os.environ.get("OUTPUT_REPO", "evalstate/qwen-capybara-medium-gguf"), "OUTPUT_REPO")
 username = require_hf_id(os.environ.get("HF_USERNAME", ADAPTER_MODEL.split('/')[0]), "HF_USERNAME")
+TRUST_REMOTE_CODE = os.environ.get("TRUST_REMOTE_CODE", "").strip().lower() in {"1", "true", "yes"}
 
 print(f"\n📦 Configuration:")
 print(f"   Base model: {BASE_MODEL}")
@@ -147,7 +148,7 @@ try:
         BASE_MODEL,
         dtype=torch.float16,
         device_map="auto",
-        trust_remote_code=True,
+        trust_remote_code=TRUST_REMOTE_CODE,
     )
     print("   ✅ Base model loaded")
 except Exception as e:
@@ -169,7 +170,7 @@ except Exception as e:
 
 try:
     # Load tokenizer
-    tokenizer = AutoTokenizer.from_pretrained(ADAPTER_MODEL, trust_remote_code=True)
+    tokenizer = AutoTokenizer.from_pretrained(ADAPTER_MODEL, trust_remote_code=TRUST_REMOTE_CODE)
     print("   ✅ Tokenizer loaded")
 except Exception as e:
     print(f"   ❌ Failed to load tokenizer: {e}")

package/bundled-skills/infinity/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: infinity
+description: "Enforces a strict input boundary protocol (detect, classify, filter, verify) to ensure untrusted data never reaches business logic raw."
+risk: safe
+source: community
+date_added: "2026-06-23"
+---
+
+# infinity — Input Boundary & Validation Protocol
+
+## Core Philosophy
+
+> Nothing untrusted ever reaches the core — it is stopped before contact. No external data touches the codebase raw. Every boundary where data enters the system must have a filter.
+
+The #1 source of silent bugs, crashes, and vulnerabilities is external data that arrives in an unexpected shape and gets used directly without checking. This skill enforces a filter layer at every entry point, every time.
+
+---
+
+## When to Use This Skill
+
+- Use when you need to handle an API response
+- Use when reading user input or adding a form handler
+- Use when working with environment variables or CLI arguments
+- Use when parsing webhooks or reading from the filesystem
+- Use when any code calls `.body`, `.params`, `.query`, `.env`, `fs.read`, or a third-party SDK response
+
+---
+
+## The Four Phases
+
+### PHASE 1 — Boundary Detection
+
+Before writing or modifying any code that involves external data, the AI must identify and list every entry point in scope:
+
+- HTTP request bodies, headers, query params
+- User form inputs and UI-submitted data
+- Environment variables and config files
+- Third-party API responses
+- Webhook payloads
+- File reads from disk
+- CLI arguments
+- Database query results from external sources
+- WebSocket messages
+
+> **The AI must not write any data-handling logic until every entry point in scope is listed.**
+
+---
+
+### PHASE 2 — Classify Each Input
+
+For every entry point identified, the AI classifies it into one of three trust levels:
+
+| Level | Definition | Examples |
+|---|---|---|
+| `TRUSTED` | Internal constants, hardcoded values, your own compile-time config | Enum values, hardcoded defaults, internal constants |
+| `SEMI-TRUSTED` | Your own internal services, internal APIs, controlled infrastructure | Internal microservice responses, your own database reads |
+| `UNTRUSTED` | Anything from users, the internet, third parties, or the filesystem | User input, external API responses, uploaded files, env vars, CLI args |
+
+> **Rule:** `TRUSTED` inputs may be used directly. `SEMI-TRUSTED` and `UNTRUSTED` inputs must pass through a filter layer before any use.
+
+The AI outputs this classification before writing any handling code:
+
+```
+INFINITY — BOUNDARY MAP
+─────────────────────────────────────────
+Entry Point              | Trust Level  | Filter Required
+─────────────────────────────────────────
+req.body.email           | UNTRUSTED    | ✓ format + sanitize
+process.env.API_KEY      | UNTRUSTED    | ✓ presence + non-empty
+internalService.getData()| SEMI-TRUSTED | ✓ schema validate
+PAGINATION_LIMIT = 20    | TRUSTED      | ✗ none needed
+─────────────────────────────────────────
+```
+
+---
+
+### PHASE 3 — Mandatory Filter Layer
+
+Every `UNTRUSTED` and `SEMI-TRUSTED` input must pass through validation before it reaches any business logic, storage, or rendering. The AI must apply the right filter type for the right context:
+
+**Type Checking**
+- Verify the input is the expected type before using it
+- Never assume a string is a string, a number is a number, or an array is an array
+
+**Schema Validation**
+- For objects and API responses, validate shape before accessing nested fields
+- If a required field is missing, reject — do not use a fallback that hides the problem
+
+**Sanitization**
+- Strip or escape content before rendering to UI (prevent XSS)
+- Normalize strings before storage (trim whitespace, consistent casing where appropriate)
+
+**Presence & Format Checks**
+- Env vars: must exist and be non-empty before use
+- IDs and tokens: must match expected format before use
+
+**Rejection Rule**
+- On invalid input: reject explicitly and return a clear error
+- Never silently use bad data with a fallback
+- Never let bad data pass through to fix itself "downstream"
+
+```
+// WRONG — using raw input directly
+const user = await db.find(req.params.id);
+
+// RIGHT — validate before use
+const id = req.params.id;
+if (!id || typeof id !== 'string' || !isValidUUID(id)) {
+  return res.status(400).json({ error: 'Invalid ID format' });
+}
+const user = await db.find(id);
+```
+
+---
+
+### PHASE 4 — Self-Check Before Done
+
+Before the AI declares any data-handling code complete, it traces each entry point and confirms:
+
+```
+INFINITY — VERIFICATION
+─────────────────────────────────────────
+Entry Point              | Filter Exists | Filter Type
+─────────────────────────────────────────
+req.body.email           | ✓ YES         | format + sanitize
+process.env.API_KEY      | ✓ YES         | presence check
+internalService.getData()| ✓ YES         | schema validation
+─────────────────────────────────────────
+Unfiltered inputs reaching logic: NONE ✓
+─────────────────────────────────────────
+```
+
+If any `UNTRUSTED` or `SEMI-TRUSTED` input reaches logic, storage, or rendering without a filter — the AI flags it. It does not silently pass.
+
+---
+
+## Hard Rules (Never Violated)
+
+- **No raw external data in business logic.** Ever.
+- **No silent fallbacks on bad input.** Reject explicitly.
+- **No assuming shape.** Even if the API "always" returns a string — validate it.
+- **No skipping env var checks.** Missing env vars must fail loudly at startup, not silently at runtime.
+- **No partial filtering.** If you validate presence but not format, it is not filtered.
+- **No filtering in the wrong place.** Filters go at the entry point — not somewhere downstream after the data has already been used once.
+
+---
+
+## What This Skill Prevents
+
+- SQL injection via unvalidated query params
+- Crashes from unexpected API response shapes
+- XSS from unescaped user content rendered to UI
+- Silent failures from missing env variables discovered at runtime
+- Type errors from assuming external data matches expected shape
+- Security vulnerabilities from untrusted data reaching sensitive operations
+
+---
+
+## Quick Reference
+
+| Phase | Action | Writes Code? |
+|---|---|---|
+| 1 — Detect | List all entry points in scope | ❌ No |
+| 2 — Classify | Assign trust level to each input | ❌ No |
+| 3 — Filter | Write filter layer for all UNTRUSTED + SEMI-TRUSTED | ✅ Yes |
+| 4 — Verify | Trace each input, confirm filter exists | ❌ No |
+
+---
+
+## Limitations
+
+- Does not apply to purely internal logic with no external data involvement.
+- May add verbosity to trivial scripts where strict validation is not required.

package/bundled-skills/loki-mode/autonomy/run.sh

@@ -711,21 +711,30 @@ generate_dashboard() {
             if (seconds < 3600) return Math.floor(seconds / 60) + 'm';
             return Math.floor(seconds / 3600) + 'h ' + Math.floor((seconds % 3600) / 60) + 'm';
         }
+        function escapeHtml(value) {
+            return String(value ?? '').replace(/[&<>"']/g, (char) => ({
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&#39;'
+            })[char]);
+        }
         function renderAgent(agent) {
             const modelClass = getModelClass(agent.model);
-            const modelName = agent.model || 'Sonnet 4.5';
-            const agentType = agent.agent_type || 'general-purpose';
+            const modelName = escapeHtml(agent.model || 'Sonnet 4.5');
+            const agentType = escapeHtml(agent.agent_type || 'general-purpose');
             const status = agent.status === 'completed' ? 'completed' : 'active';
-            const currentTask = agent.current_task || (agent.tasks_completed && agent.tasks_completed.length > 0
+            const currentTask = escapeHtml(agent.current_task || (agent.tasks_completed && agent.tasks_completed.length > 0
                 ? 'Completed: ' + agent.tasks_completed.join(', ')
-                : 'Initializing...');
+                : 'Initializing...'));
             const duration = formatDuration(agent.spawned_at);
             const tasksCount = agent.tasks_completed ? agent.tasks_completed.length : 0;
 
             return `
                 <div class="agent-card">
                     <div class="agent-header">
-                        <div class="agent-id">${agent.agent_id || 'Unknown'}</div>
+                        <div class="agent-id">${escapeHtml(agent.agent_id || 'Unknown')}</div>
                         <div class="model-badge ${modelClass}">${modelName}</div>
                     </div>
                     <div class="agent-type">${agentType}</div>
@@ -740,9 +749,9 @@ generate_dashboard() {
         }
         function renderTask(task) {
             const payload = task.payload || {};
-            const title = payload.description || payload.action || task.type || 'Task';
-            const error = task.lastError ? `<div class="error">${task.lastError}</div>` : '';
-            return `<div class="task"><div class="id">${task.id}</div><span class="type">${task.type || 'general'}</span><div class="title">${title}</div>${error}</div>`;
+            const title = escapeHtml(payload.description || payload.action || task.type || 'Task');
+            const error = task.lastError ? `<div class="error">${escapeHtml(task.lastError)}</div>` : '';
+            return `<div class="task"><div class="id">${escapeHtml(task.id)}</div><span class="type">${escapeHtml(task.type || 'general')}</span><div class="title">${title}</div>${error}</div>`;
         }
         async function loadData() {
             const [pending, progress, completed, failed, agents] = await Promise.all([

package/bundled-skills/loki-mode/examples/todo-app-generated/backend/package-lock.json

@@ -8,10 +8,10 @@
       "name": "todo-app-backend",
       "version": "1.0.0",
       "dependencies": {
-        "better-sqlite3": "^12.8.0",
-        "cors": "^2.8.5",
+        "better-sqlite3": "^12.10.0",
+        "cors": "^2.8.6",
         "express": "^4.18.2",
-        "express-rate-limit": "^8.5.1",
+        "express-rate-limit": "^8.5.2",
         "ip-address": "^10.2.0"
       },
       "devDependencies": {
@@ -303,9 +303,9 @@
       "license": "MIT"
     },
     "node_modules/better-sqlite3": {
-      "version": "12.8.0",
-      "resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.8.0.tgz",
-      "integrity": "sha512-RxD2Vd96sQDjQr20kdP+F+dK/1OUNiVOl200vKBZY8u0vTwysfolF6Hq+3ZK2+h8My9YvZhHsF+RSGZW2VYrPQ==",
+      "version": "12.10.0",
+      "resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.10.0.tgz",
+      "integrity": "sha512-CyzaZRQKyHkB2ZInfTTl2nvT33EbDpjkLEbE8/Zck3Ll6O0qqvuGdrJ45HgtH+HykRg88ITY3AdreBGN70aBSQ==",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {
@@ -313,7 +313,7 @@
         "prebuild-install": "^7.1.1"
       },
       "engines": {
-        "node": "20.x || 22.x || 23.x || 24.x || 25.x"
+        "node": "20.x || 22.x || 23.x || 24.x || 25.x || 26.x"
       }
     },
     "node_modules/bindings": {
@@ -459,9 +459,9 @@
       "license": "MIT"
     },
     "node_modules/cors": {
-      "version": "2.8.5",
-      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
-      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "version": "2.8.6",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
+      "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
       "license": "MIT",
       "dependencies": {
         "object-assign": "^4",
@@ -469,6 +469,10 @@
       },
       "engines": {
         "node": ">= 0.10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
     "node_modules/create-require": {
@@ -688,9 +692,9 @@
       }
     },
     "node_modules/express-rate-limit": {
-      "version": "8.5.1",
-      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.5.1.tgz",
-      "integrity": "sha512-5O6KYmyJEpuPJV5hNTXKbAHWRqrzyu+OI3vUnSd2kXFubIVpG7ezpgxQy76Zo5GQZtrQBg86hF+CM/NX+cioiQ==",
+      "version": "8.5.2",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.5.2.tgz",
+      "integrity": "sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==",
       "license": "MIT",
       "dependencies": {
         "ip-address": "^10.2.0"

package/bundled-skills/loki-mode/examples/todo-app-generated/backend/package.json

@@ -9,10 +9,10 @@
     "dev": "ts-node src/index.ts"
   },
   "dependencies": {
-    "better-sqlite3": "^12.8.0",
-    "cors": "^2.8.5",
+    "better-sqlite3": "^12.10.0",
+    "cors": "^2.8.6",
     "express": "^4.18.2",
-    "express-rate-limit": "^8.5.1",
+    "express-rate-limit": "^8.5.2",
     "ip-address": "^10.2.0"
   },
   "devDependencies": {

package/bundled-skills/macos-spm-app-packaging/assets/templates/setup_dev_signing.sh

@@ -14,8 +14,13 @@ fi
 
 echo "Creating self-signed certificate '$CERT_NAME'..."
 
-TEMP_CONFIG=$(mktemp)
-trap "rm -f $TEMP_CONFIG" EXIT
+TEMP_DIR=$(mktemp -d)
+chmod 700 "$TEMP_DIR"
+TEMP_CONFIG="$TEMP_DIR/dev.cnf"
+KEY_PATH="$TEMP_DIR/dev.key"
+CRT_PATH="$TEMP_DIR/dev.crt"
+P12_PATH="$TEMP_DIR/dev.p12"
+trap 'rm -rf "$TEMP_DIR"' EXIT
 
 cat > "$TEMP_CONFIG" <<EOFCONF
 [ req ]
@@ -34,18 +39,16 @@ extendedKeyUsage = codeSigning
 EOFCONF
 
 openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 \
-    -nodes -keyout /tmp/dev.key -out /tmp/dev.crt \
+    -nodes -keyout "$KEY_PATH" -out "$CRT_PATH" \
     -config "$TEMP_CONFIG" 2>/dev/null
 
-openssl pkcs12 -export -out /tmp/dev.p12 \
-    -inkey /tmp/dev.key -in /tmp/dev.crt \
+openssl pkcs12 -export -out "$P12_PATH" \
+    -inkey "$KEY_PATH" -in "$CRT_PATH" \
     -passout pass: 2>/dev/null
 
-security import /tmp/dev.p12 -k ~/Library/Keychains/login.keychain-db \
+security import "$P12_PATH" -k ~/Library/Keychains/login.keychain-db \
   -T /usr/bin/codesign -T /usr/bin/security
 
-rm -f /tmp/dev.{key,crt,p12}
-
 echo ""
 echo "Trust this certificate for code signing in Keychain Access."
 echo "Then export in your shell profile:"

package/bundled-skills/macos-spm-app-packaging/assets/templates/sign-and-notarize.sh

@@ -13,8 +13,13 @@ if [[ -z "${APP_STORE_CONNECT_API_KEY_P8:-}" || -z "${APP_STORE_CONNECT_KEY_ID:-
   exit 1
 fi
 
-echo "$APP_STORE_CONNECT_API_KEY_P8" | sed 's/\\n/\n/g' > /tmp/app-store-connect-key.p8
-trap 'rm -f /tmp/app-store-connect-key.p8 /tmp/${APP_NAME}Notarize.zip' EXIT
+TEMP_DIR=$(mktemp -d)
+chmod 700 "$TEMP_DIR"
+KEY_PATH="$TEMP_DIR/app-store-connect-key.p8"
+NOTARY_ZIP="$TEMP_DIR/${APP_NAME}Notarize.zip"
+trap 'rm -rf "$TEMP_DIR"' EXIT
+
+echo "$APP_STORE_CONNECT_API_KEY_P8" | sed 's/\\n/\n/g' > "$KEY_PATH"
 
 ARCHES_VALUE=${ARCHES:-"arm64 x86_64"}
 ARCH_LIST=( ${ARCHES_VALUE} )
@@ -31,10 +36,10 @@ codesign --force --timestamp --options runtime --sign "$APP_IDENTITY" \
   "$APP_BUNDLE"
 
 DITTO_BIN=${DITTO_BIN:-/usr/bin/ditto}
-"$DITTO_BIN" --norsrc -c -k --keepParent "$APP_BUNDLE" "/tmp/${APP_NAME}Notarize.zip"
+"$DITTO_BIN" --norsrc -c -k --keepParent "$APP_BUNDLE" "$NOTARY_ZIP"
 
-xcrun notarytool submit "/tmp/${APP_NAME}Notarize.zip" \
-  --key /tmp/app-store-connect-key.p8 \
+xcrun notarytool submit "$NOTARY_ZIP" \
+  --key "$KEY_PATH" \
   --key-id "$APP_STORE_CONNECT_KEY_ID" \
   --issuer "$APP_STORE_CONNECT_ISSUER_ID" \
   --wait

package/bundled-skills/pptx-official/ooxml/scripts/pack.py

@@ -16,6 +16,17 @@ import zipfile
 from pathlib import Path
 
 
+def validate_input_tree(input_dir: Path):
+    root = input_dir.resolve(strict=True)
+    for path in input_dir.rglob("*"):
+        if path.is_symlink():
+            raise ValueError(f"Refusing to pack symlink: {path}")
+        try:
+            path.resolve(strict=True).relative_to(root)
+        except (OSError, ValueError):
+            raise ValueError(f"Refusing to pack path outside input directory: {path}") from None
+
+
 def main():
     parser = argparse.ArgumentParser(description="Pack a directory into an Office file")
     parser.add_argument("input_directory", help="Unpacked Office document directory")
@@ -60,6 +71,7 @@ def pack_document(input_dir, output_file, validate=False):
         raise ValueError(f"{input_dir} is not a directory")
     if output_file.suffix.lower() not in {".docx", ".pptx", ".xlsx"}:
         raise ValueError(f"{output_file} must be a .docx, .pptx, or .xlsx file")
+    validate_input_tree(input_dir)
 
     # Work in temporary directory to avoid modifying original
     with tempfile.TemporaryDirectory() as temp_dir:

package/bundled-skills/pptx-official/ooxml/scripts/unpack.py

@@ -8,6 +8,11 @@ import sys
 import zipfile
 from pathlib import Path
 
+MAX_ARCHIVE_MEMBERS = 5000
+MAX_MEMBER_SIZE = 100 * 1024 * 1024
+MAX_TOTAL_UNCOMPRESSED = 512 * 1024 * 1024
+MAX_COMPRESSION_RATIO = 1000
+
 
 def _is_zip_symlink(member: zipfile.ZipInfo) -> bool:
     return stat.S_ISLNK(member.external_attr >> 16)
@@ -29,19 +34,35 @@ def _extract_member(archive: zipfile.ZipFile, member: zipfile.ZipInfo, output_ro
         shutil.copyfileobj(source, target)
 
 
+def _validate_archive_members(archive: zipfile.ZipFile, output_root: Path):
+    members = archive.infolist()
+    if len(members) > MAX_ARCHIVE_MEMBERS:
+        raise ValueError("Archive contains too many entries")
+
+    total_size = 0
+    for member in members:
+        if _is_zip_symlink(member):
+            raise ValueError(f"Unsafe archive entry: {member.filename}")
+        if not _is_safe_destination(output_root, member.filename):
+            raise ValueError(f"Unsafe archive entry: {member.filename}")
+        if member.file_size > MAX_MEMBER_SIZE:
+            raise ValueError(f"Archive entry too large: {member.filename}")
+        total_size += member.file_size
+        if total_size > MAX_TOTAL_UNCOMPRESSED:
+            raise ValueError("Archive uncompressed size is too large")
+        if member.compress_size and member.file_size / member.compress_size > MAX_COMPRESSION_RATIO:
+            raise ValueError(f"Archive entry compression ratio too high: {member.filename}")
+
+    return members
+
+
 def extract_archive_safely(input_file: str | Path, output_dir: str | Path):
     output_path = Path(output_dir)
     output_path.mkdir(parents=True, exist_ok=True)
     output_root = output_path.resolve()
 
     with zipfile.ZipFile(input_file) as archive:
-        for member in archive.infolist():
-            if _is_zip_symlink(member):
-                raise ValueError(f"Unsafe archive entry: {member.filename}")
-            if not _is_safe_destination(output_root, member.filename):
-                raise ValueError(f"Unsafe archive entry: {member.filename}")
-
-        for member in archive.infolist():
+        for member in _validate_archive_members(archive, output_root):
             _extract_member(archive, member, output_path)
 
 

package/bundled-skills/pptx-official/ooxml/scripts/validation/base.py

@@ -9,6 +9,14 @@ from pathlib import Path
 import lxml.etree
 
 
+def hardened_xml_parser():
+    return lxml.etree.XMLParser(resolve_entities=False, no_network=True, load_dtd=False, huge_tree=False)
+
+
+def parse_xml(source, **kwargs):
+    return lxml.etree.parse(source, parser=hardened_xml_parser(), **kwargs)
+
+
 def safe_extract_all(zip_ref, destination):
     """Extract a zip archive without allowing members to escape destination."""
     destination = Path(destination).resolve()
@@ -149,7 +157,7 @@ class BaseSchemaValidator:
         for xml_file in self.xml_files:
             try:
                 # Try to parse the XML file
-                lxml.etree.parse(str(xml_file))
+                parse_xml(str(xml_file))
             except lxml.etree.XMLSyntaxError as e:
                 errors.append(
                     f"  {xml_file.relative_to(self.unpacked_dir)}: "
@@ -177,7 +185,7 @@ class BaseSchemaValidator:
 
         for xml_file in self.xml_files:
             try:
-                root = lxml.etree.parse(str(xml_file)).getroot()
+                root = parse_xml(str(xml_file)).getroot()
                 declared = set(root.nsmap.keys()) - {None}  # Exclude default namespace
 
                 for attr_val in [
@@ -208,7 +216,7 @@ class BaseSchemaValidator:
 
         for xml_file in self.xml_files:
             try:
-                root = lxml.etree.parse(str(xml_file)).getroot()
+                root = parse_xml(str(xml_file)).getroot()
                 file_ids = {}  # Track IDs that must be unique within this file
 
                 # Remove all mc:AlternateContent elements from the tree
@@ -328,7 +336,7 @@ class BaseSchemaValidator:
         for rels_file in rels_files:
             try:
                 # Parse relationships file
-                rels_root = lxml.etree.parse(str(rels_file)).getroot()
+                rels_root = parse_xml(str(rels_file)).getroot()
 
                 # Get the directory where this .rels file is located
                 rels_dir = rels_file.parent
@@ -429,7 +437,7 @@ class BaseSchemaValidator:
 
             try:
                 # Parse the .rels file to get valid relationship IDs and their types
-                rels_root = lxml.etree.parse(str(rels_file)).getroot()
+                rels_root = parse_xml(str(rels_file)).getroot()
                 rid_to_type = {}
 
                 for rel in rels_root.findall(
@@ -452,7 +460,7 @@ class BaseSchemaValidator:
                         rid_to_type[rid] = type_name
 
                 # Parse the XML file to find all r:id references
-                xml_root = lxml.etree.parse(str(xml_file)).getroot()
+                xml_root = parse_xml(str(xml_file)).getroot()
 
                 # Find all elements with r:id attributes
                 for elem in xml_root.iter():
@@ -549,7 +557,7 @@ class BaseSchemaValidator:
 
         try:
             # Parse and get all declared parts and extensions
-            root = lxml.etree.parse(str(content_types_file)).getroot()
+            root = parse_xml(str(content_types_file)).getroot()
             declared_parts = set()
             declared_extensions = set()
 
@@ -611,7 +619,7 @@ class BaseSchemaValidator:
                     continue
 
                 try:
-                    root_tag = lxml.etree.parse(str(xml_file)).getroot().tag
+                    root_tag = parse_xml(str(xml_file)).getroot().tag
                     root_name = root_tag.split("}")[-1] if "}" in root_tag else root_tag
 
                     if root_name in declarable_roots and path_str not in declared_parts:
@@ -850,15 +858,12 @@ class BaseSchemaValidator:
         try:
             # Load schema
             with open(schema_path, "rb") as xsd_file:
-                parser = lxml.etree.XMLParser()
-                xsd_doc = lxml.etree.parse(
-                    xsd_file, parser=parser, base_url=str(schema_path)
-                )
+                xsd_doc = parse_xml(xsd_file, base_url=str(schema_path))
                 schema = lxml.etree.XMLSchema(xsd_doc)
 
             # Load and preprocess XML
             with open(xml_file, "r") as f:
-                xml_doc = lxml.etree.parse(f)
+                xml_doc = parse_xml(f)
 
             xml_doc, _ = self._remove_template_tags_from_text_nodes(xml_doc)
             xml_doc = self._preprocess_for_mc_ignorable(xml_doc)

package/bundled-skills/pptx-official/ooxml/scripts/validation/docx.py

@@ -10,7 +10,7 @@ from pathlib import Path
 
 import lxml.etree
 
-from .base import BaseSchemaValidator
+from .base import BaseSchemaValidator, parse_xml
 
 
 def safe_extract_all(zip_ref, destination):
@@ -100,7 +100,7 @@ class DOCXSchemaValidator(BaseSchemaValidator):
                 continue
 
             try:
-                root = lxml.etree.parse(str(xml_file)).getroot()
+                root = parse_xml(str(xml_file)).getroot()
 
                 # Find all w:t elements
                 for elem in root.iter(f"{{{self.WORD_2006_NAMESPACE}}}t"):
@@ -153,7 +153,7 @@ class DOCXSchemaValidator(BaseSchemaValidator):
                 continue
 
             try:
-                root = lxml.etree.parse(str(xml_file)).getroot()
+                root = parse_xml(str(xml_file)).getroot()
 
                 # Find all w:t elements that are descendants of w:del elements
                 namespaces = {"w": self.WORD_2006_NAMESPACE}
@@ -199,7 +199,7 @@ class DOCXSchemaValidator(BaseSchemaValidator):
                 continue
 
             try:
-                root = lxml.etree.parse(str(xml_file)).getroot()
+                root = parse_xml(str(xml_file)).getroot()
                 # Count all w:p elements
                 paragraphs = root.findall(f".//{{{self.WORD_2006_NAMESPACE}}}p")
                 count = len(paragraphs)
@@ -221,7 +221,7 @@ class DOCXSchemaValidator(BaseSchemaValidator):
 
                 # Parse document.xml
                 doc_xml_path = temp_dir + "/word/document.xml"
-                root = lxml.etree.parse(doc_xml_path).getroot()
+                root = parse_xml(doc_xml_path).getroot()
 
                 # Count all w:p elements
                 paragraphs = root.findall(f".//{{{self.WORD_2006_NAMESPACE}}}p")
@@ -244,7 +244,7 @@ class DOCXSchemaValidator(BaseSchemaValidator):
                 continue
 
             try:
-                root = lxml.etree.parse(str(xml_file)).getroot()
+                root = parse_xml(str(xml_file)).getroot()
                 namespaces = {"w": self.WORD_2006_NAMESPACE}
 
                 # Find w:delText in w:ins that are NOT within w:del