⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

blender-pipeline

freedomintelligence@freedomintelligence⭐ 100 stars· last commit 1mo ago· 0 open issues

Extract a tutorial or reconstruct a Blender result from video links, local videos with supporting assets, or Markdown tutorials in Codex chat. Clarify the intended output when unspecified; also route explicit showcase reproduction and independent asset edits.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 100 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

English | 简体中文

🔭 Overview

BlenderLore is a dataset and pipeline for acquiring and reusing procedural knowledge from internet tutorial videos for 3D coding. It converts video evidence into illustrated tutorials, reconstructs editable assets in Blender Python, and extracts reviewed methods for future creation tasks. The collection contains about 22K project instances associated with over 3K tutorial videos from YouTube and Bilibili.

Generalization is central to BlenderLore. Executing code and inspecting geometry, appearance, and motion ground the inferred methods in concrete implementations. Agents can then retrieve, adapt, and combine methods from different tutorials for new goals. BlenderLore Skill packages the reconstruction workflow and procedural knowledge library for existing coding agents; knowledge accumulates externally without updating model parameters.

A complete BlenderLore example: dynamic fur, from tutorial evidence to illustrated steps, Blender Python, and an animated asset

A complete example: dynamic fur. Illustrated steps connect the source video to executable reconstruction and reusable procedural knowledge.

🧩 Method

BlenderLore pipeline: tutorial videos, multimodal evidence, illustrated workflows and knowledge retrieval, a coding agent loop, and verified deliverables

  1. Recover illustrated workflows. Align video frames, narration, on-screen text, and interface changes into ordered steps, recording inputs, operations, parameters, and intermediate results.
  2. Ground methods in source assets. Use creator-provided projects when available, repair missing components, and connect tutorial steps to concrete implementations.
  3. Reconstruct and inspect. Retrieve relevant knowledge, generate Blender Python, execute and render the scene, and repair discrepancies in geometry, appearance, or motion.
  4. Review and retain knowledge. Record each method's source, retrieval keywords, applicability, implementation excerpt, and checks for the intended result. Human experts review the resulting assets.
  5. Adapt and combine. Reuse methods across tutorials to create new assets and expand the procedural knowledge library.

Generalizing Beyond Tutorials

Cross-tutorial composition: Duck GiGi modeling, transferred rigging and walking, and an iridescent material

BlenderLore creates a walking iridescent Duck GiGi by combining three tutorials: a static character modeling workflow, a rigging and walking method transferred from a baby crocodile, and an iridescent material. The reusable unit is a construction method, allowing agents to adapt and combine knowledge beyond the demonstrated assets.

🎁 What You Get

01 · An End-to-End Agent Pipeline

Each run recreates a tutorial workflow and delivers an editable Blender project, a reproduction script, renders, and validation results.

  • Editable Asset — asset.blend
  • Reproduction Script — reproduce.py
  • Materials & Node Graphs
  • Final Render
  • Multi-View Renders
  • Animation
  • Agent Log

02 · A High-Quality 3D Dataset

About 22K project instances associated with over 3K tutorial videos, built through collection, repair, reconstruction, and cross-tutorial adaptation and composition. Human experts manually check every final asset file.

03 · A Reusable Procedural Knowledge Library

Reviewed entries record their source, applicability, implementation, and checks. BlenderLore Skill supplies this library and workflow guidance so coding agents can retrieve, adapt, and combine methods for new 3D tasks.

🚀 Quick Start

1. Install prerequisites

Install Python 3.10+, Blender, and FFmpeg (including ffprobe), with Blender and FFmpeg on PATH. Commands below target macOS/Linux; on Windows, use Linux Python and Blender in WSL. Replace example paths with your own.

git clone https://github.com/FreedomIntelligence/BlenderLore.git
cd BlenderLore
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt

For Codex, install and sign in to Codex CLI using the official documentation, and ensure the client can run codex.

2. Install Skills

Run from the repository root to install the Skill into the current user's Codex environment:

mkdir -p "$HOME/.agents/skills"
ln -s "$PWD/skills/blender-pipeline" "$HOME/.agents/skills/blender-pipeline"

3. Configure rendering

Cycles uses the CPU by default. Omit the Blender path setting if Blender is already on PATH.

export BLENDER_PIPELINE_BLENDER=/path/to/blender
export VIDEO2BLENDER_CYCLES_BACKEND=CPU

For GPU rendering, replace CPU with the appropriate backend: OPTIX or CUDA for NVIDIA, METAL for Apple Silicon, HIP for AMD, or ONEAPI for Intel.

4. Configure inputs and outputs

Keep input files on your computer. For API mode, enter their paths in the terminal launch command in step 5; for Codex, provide paths or links directly in the client's chat composer.

InputAPI argumentProvide in Codex
Local video--video-fileAbsolute path to the video
Video URL--video-urlFull HTTPS video URL
Markdown tutorial--tutorialAbsolute path to the .md file

Markdown tutorials need numbered operations and their referenced images. Text-only tutorials also require a final reference image.

Choose a new or empty output directory outside the repository: use --output-dir in API mode, or specify it in the Codex conversation. Output formats are fixed; main files appear as their corresponding stages complete:

run_001/
  tutorial.md             # Illustrated tutorial
  reproduce.py            # Blender Python code
  asset.blend             # Editable project
  render.png              # Rendered image
  six_views/              # Static multi-view renders, when applicable
  final_effect.mp4        # Animation or turntable video, when applicable
  pipeline_review.json    # Review results

5. Start with API / Codex

API

Open a terminal at the repository root and run this command for first-time setup:

python run_api.py --configure --config "$HOME/.config/blender-pipeline/pipeline.json"

At the terminal prompts, enter an HTTPS API endpoint ending in /chat/completions and your API key. The endpoint is saved in the endpoint field of ~/.config/blender-pipeline/pipeline.json; the key is saved in model_api_key in the same directory. Edit these files to change the configuration later.

Launch from the same terminal, replacing the input path and output directory with your own. Use the corresponding argument from step 4 for other input types:

python run_api.py --config "$HOME/.config/blender-pipeline/pipeline.json" \
  --video-file /path/to/input/tutorial.mp4 --output-dir /path/to/data/run_api

F

// HOW IT'S BUILT

// FILES

117 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/blender-pipeline/editing/SKILL.md6.0 KBb76259d09cfdupstream ↗
    ---
    name: blender-existing-asset-editing
    description: Edit a declared part of an existing Blender project while preserving its authored composition, verifying non-target stability, and producing a reopen-verified receipt. Use for material, color, geometry, modeling, or scene edits; use a generation workflow when the whole asset must be created from zero.
    ---
    
    # Blender Existing-Asset Editing
    
    Use this workflow when the source is an existing `.blend` project and only a declared scope should change. The source project does not need to have been produced by a generation pipeline. Any replacement asset introduced by the edit must come from the authorized generation process or from declarative geometry in the reviewed request; this package never executes arbitrary request code.
    
    ## Runtime boundary
    
    Install the ordinary Python package from this directory:
    
    ```bash
    python -m pip install -e '.[test]'
    python -m unittest discover -s tests -v
    ```
    
    `bpy` is deliberately not a pip dependency. Run project inspection and mutation with the Python bundled in Blender. Pass every source, request, and output path explicitly; do not put workstation or server paths into code or receipts.
    
    ## Required workflow
    
    1. Create an edit request conforming to `schemas/edit_request.schema.json`. Bind it to the exact source file SHA-256 and name every target.
    2. Run preflight before mutation. Reject a source hash mismatch, absent targets, linked read-only targets, missing external dependencies, or a request that overlaps its output.
    3. Capture a deterministic source snapshot. Apply exactly one edit kind: `material`, `color`, `geometry`, `modeling`, or `scene`.
    4. Preserve authored structure outside the declared scope. Material edits retain the node tree and change only declared materials. Geometry edits retain object identity, transforms, collections, and material slots. Modeling may add only explicitly named generated objects or approved modifiers. Scene edits touch only declared lights, camera, world, or exposure fields. Snapshots expose constraints, drivers, NLA, compositor state, and important render/color settings so undeclared drift fails closed.
    5. Geometry may use declarative vertices/faces or a generation handoff. A handoff must bind an accepted GEN-V3 attempt receipt by file SHA and receipt self-hash, bind the receipt's exact `asset.blend` by SHA/size, and name one mesh object. The evaluated donor mesh is fitted into the target envelope while the target object and its material slots remain authoritative. Compare the target's evaluated visible world mesh before and after at the evidence frame; record and verify transform/orientation, world envelope center, per-axis envelope ratios, and bounding-box volume ratio. Geometry targets with shape keys, animation/drivers/NLA, constraints, armature or simulation dependencies, instancing, or mismatched viewport/render modifier settings are outside this single-frame review contract and fail closed.
    6. Run `prepare`: render before, apply, pack, validate non-target drift, save and reopen `candidate.blend`, render after with the same camera/settings, and atomically publish an `awaiting_review` package. Structural success is not completion.
    7. Obtain an external human or VLM assessment conforming to `schemas/assessment.schema.json`. It must bind `review_package.json`, `candidate.blend`, `before.png`, and `after.png` by SHA-256, score both versions, keep `after >= before`, and meet the request threshold (at least 80).
    8. Run `finalize`: verify every binding, reopen the assessed candidate, match its saved snapshot, then atomically publish `asset.blend`, evidence, assessment, and a non-null-visual `complete` receipt. A failed or unreviewed run must not publish a completed result.
    
    Do not clear a material node tree to perform a local edit. Do not silently resize a replacement: geometry replacement is fitted to the source local bounding box by default and checked against declared envelope, volume-ratio, and world-center tolerances. Inline replacements must rebuild every source UV layer; generation handoffs must retain those layer names. Unsupported shape keys or color attributes fail preflight instead of being discarded. Visual evidence and external review are mandatory for completion; `evidence.render=false` is invalid.
    
    ## Commands
    
    Validate a request outside Blender:
    
    ```bash
    python -m blender_edit_pipeline.pipeline validate-request --request edit.json
    ```
    
    Preflight, prepare, and finalize inside Blender (arguments after `--` belong to the pipeline):
    
    ```bash
    blender source.blend --background --python src/blender_edit_pipeline/pipeline.py -- preflight --request edit.json --output source_map.json
    blender source.blend --background --python src/blender_edit_pipeline/pipeline.py -- prepare --request edit.json --review-dir review
    blender --background --python src/blender_edit_pipeline/pipeline.py -- finalize --review-dir review --assessment assessment.json --output-dir edited
    ```
    
    `apply --output-dir review` remains a compatibility alias for `prepare`; it produces `awaiting_review`, never `complete`. Use `--overwrite` only when replacement of an existing review or completed output was explicitly authorized. The implementation keeps a backup until the new directory is in place.
    
    ## Request modes
    
    - `material`: set declared Principled-BSDF inputs without destroying the graph.
    - `color`: set Base Color or insert a Hue/Saturation node at the declared material input.
    - `geometry`: replace mesh data from declared vertices/faces or one SHA-bound accepted generation attempt, retaining target identity, material slots, transform, and fitted envelope.
    - `modeling`: add allowlisted primitives or modifiers declared in the request.
    - `scene`: edit declared lights, a declared camera, world color, or exposure only when those scopes are explicitly enabled.
    
    Treat an edit as complete only when `finalize` emits `status: "complete"`, `visual_evidence` contains the bound external assessment with non-regressing scores, `non_target_drift` is empty, `reopen.verified` is true, and every published artifact hash matches. An `awaiting_review` package is deliberately incomplete.
    
  • skills/blender-pipeline/generation/SKILL.md6.5 KB0060713a8cfbupstream ↗
    ---
    name: blender-pipeline-generation
    description: Generate an editable Blender asset or animation from a blank scene, either by replaying verified tutorial-video evidence or by executing a model-direct generation task. Use for from-zero reconstruction; use the edit pipeline when an existing scene or asset must be modified.
    ---
    
    # Blender Generation Pipeline
    
    Produce an editable `.blend` as the primary artifact. Treat preview renders,
    six-view images, turntables, receipts, and traces as validation evidence rather
    than substitutes for the scene.
    
    ## Choose a route
    
    - Use tutorial replay when a video or tutorial is the source of truth. Prepare
      timestamped evidence, retrieve relevant knowledge, generate the scene, then
      compare it with the verified visual references.
    - Use model-direct generation when a structured task and reference preview are
      already available. Begin from a canonical blank scene and run the bounded
      harness in `scripts/model_direct_generation_v3_harness.py`.
    - Do not use either route to edit an existing asset. Route that work to the
      sibling edit pipeline.
    
    ## Configure the environment
    
    Install `requirements.txt`; add `requirements-knowledge.txt` only when building
    or querying the semantic knowledge index. Blender supplies `bpy`, `mathutils`,
    and `bpy_extras`; never install those modules with pip. Install Blender and
    FFmpeg separately. OCR evidence additionally uses the optional `tesseract`
    executable.
    
    Paths default below this skill's `output/` directory. Override them with
    `VIDEO2BLENDER_OUTPUT_ROOT` and `BLENDER_VIDEO_ROOT`. Set `BLENDER_PIPELINE_BLENDER` to the Blender
    executable. Paid model calls require an owner-only secret file via
    `BLENDER_PIPELINE_API_KEY_FILE` and an explicit HTTPS endpoint via
    `BLENDER_PIPELINE_API_ENDPOINT` and `VIDEO_REPLAY_APPROVED_PAID_API_ENDPOINT`. Do not
    commit credentials, provider endpoints, machine mounts, or recovery authority
    files. Deprecated `PAPER12_*` options are accepted as lower-priority aliases;
    new integrations must use the `BLENDER_PIPELINE_*` prefix.
    
    ## Replay verified tutorial evidence
    
    Ordinary users should start with repository-root `run_api.py` or `run_codex.py`.
    These prepare one isolated workspace, default to a local manifest-only knowledge
    index, and invoke the following maintained stages. `codex-cli` supplies both
    tutorial extraction and downstream code-generation/visual-review calls without
    an API key. The low-level commands below are for existing prepared workspaces.
    
    1. Put the source video and any transcript under one `video-dir`.
    2. Read the sibling [tutorial extraction skill](../tutorial-extraction/SKILL.md)
       and run its canonical `extract_video_tutorial.py` entrypoint. It performs
       the selected workflow. `--tutorial-method visual` uses the
       `video-to-visual-tutorial` workflow: coarse contact sheets, focused
       frame inspection, a compact evidence ledger, and a complete learner-facing
       procedure. Run the entrypoint with `--workspace-mode` to adapt that package
       to the existing replay files. Pass actual learner assets with repeatable
       `--input-asset`; do not classify the source video or acceptance preview as
       a learner asset. `--tutorial-method legacy-rich` uses the original complete
       60-second rich windows and base64 Markdown through the same canonical
       entrypoint. Do not call those compatibility helpers as a competing public
       launcher. The visual method is recommended for videos up to ten minutes.
       Run `build_pipeline_specs.py` after extraction.
       `tutorial.md` and its derived `steps_verified.json` preserve the operational
       contract. The separate rubric is never supplied as task instructions.
       Add `--render-html` on the extractor (or `--render-tutorial-html` on the
       low-level replay orchestrator) only when a separate human-readable
       HTML view is useful; it is rendered from the same complete Markdown and never
       replaces the operational files.
    3. Run `run_video_replay_main.py --video-dir <dir>`. The orchestrator invokes
       the strict replay, version registry, render evidence, and candidate
       knowledge update stages.
    4. Require an editable scene, a successful fresh render, complete six-view
       evidence, and a turntable or validated animation delivery when motion is
       actually supported by evidence.
    
    Tutorial text and timestamped frames outrank titles and stylistic hints. Never
    invent motion merely because a requested route says “dynamic”; downgrade to a
    static result unless subject animation is proved by keyframes, Actions/NLA,
    shape keys, time-dependent materials, simulations, or equivalent runtime
    evidence. Preserve the demonstrated asset family, silhouette, detail density,
    camera framing, lighting, and material response.
    
    Two legacy route labels remain in receipts for compatibility. `RW1` means
    source-project replay: preserve authored scene content and real subject motion,
    using bounded replacement framing only when the authored camera is unusable.
    `RW2` means a multi-part tutorial-series reconstruction: the tutorial and
    verified steps are authoritative, and unrelated title-card or editor tail
    frames must not become final visual references. Neither label denotes the
    existing-asset edit pipeline.
    
    ## Run model-direct generation
    
    Use `model_direct_generation_v3_harness.py create-blank` to establish the
    canonical blank scene, then validate the exact-50 release task index.
    `run-task` selects one item from that release index. The current `run-batch`
    command rejects any other batch size and must not be presented as a general
    batch runner. Supply explicit call and token budgets. Generated `generate.py`
    must be self-contained Blender code: the contract rejects filesystem escape,
    network access, subprocesses, dynamic imports, external project loading, and
    private provenance. Each attempt is immutable and must reopen the saved blend,
    render fresh evidence, and pass both the generation rubric and visual judge.
    
    ## Knowledge lifecycle
    
    Build a portable manifest with
    `build_blender_knowledge_index.py --manifest-only`; install the optional
    knowledge dependencies to build Qdrant. Retrieve with
    `retrieve_blender_knowledge.py --video-dir <dir>`. New replay observations are
    successful candidate knowledge only and remain outside active retrieval.
    Admission requires five independent human-reviewed accepted assets, a disjoint
    human-reviewed accepted holdout with zero regression, artifact hashes, and
    explicit route/family/Blender-version scope. Failed runs are diagnostics, never
    active lessons. Production evidence is ingested only through an explicit,
    bounded `--external-manifest`; the builder never crawls local run outputs.
    
  • skills/blender-pipeline/reproduction/SKILL.md2.6 KB3f24ec65d625upstream ↗
    ---
    name: blender-pipeline-reproduction
    description: Reproduce a maintained Blender showcase recipe from authorized video, tutorial, image, or local asset inputs while enforcing visual-acceptance and asset-distribution gates.
    ---
    
    # Blender Showcase Reproduction
    
    Use `scripts/reproduce.sh` to select one exact recipe. The command is a dry run
    unless the user explicitly authorizes `--execute`.
    
    The packaged public catalog is metadata-only. It records the current public
    showcase identity, input bindings, dynamic acceptance contracts, known gaps,
    and distribution policy; it contains no source assets or tutorial media. A
    public preview URL is acceptance evidence, not permission to download or reuse
    the asset. A recipe that is disabled, blocked, incomplete, or not independently
    accepted must fail before download, model invocation, or Blender execution.
    
    ## Tutorial inputs
    
    - For an authorized existing tutorial, use `--tutorial-mode provided` and one
      or more `--tutorial` files. The operational truth is `tutorial.md` plus
      `steps_verified.json`.
    - To extract an operational tutorial from video, explicitly use
      `--tutorial-mode extract`, `--video-url`, at least one `--image`, and a
      positive `--tutorial-window-budget`. Extraction delegates to the sibling
      [tutorial extraction skill](../tutorial-extraction/SKILL.md), defaults to the
      balanced profile and `gpt-5.6-sol`. The supplied `video-to-visual-tutorial`
      skill produces a complete procedure; a compatibility adapter supplies the
      existing replay files. `gpt-5.5` is an explicit whole-run fallback only and
      requires `--tutorial-fallback-reason`.
    - Paid extraction requires `BLENDER_PIPELINE_API_ENDPOINT` and an owner-only
      secret file named by `BLENDER_PIPELINE_API_KEY_FILE`. Dry runs do not read
      credentials, download media, call a model, or write a run directory.
    - Add `--render-tutorial-html` only when a human-facing display copy is useful.
      It is rendered from the same complete Markdown without a second model call and
      never replaces `tutorial.md`.
    
    ## Asset delivery
    
    Follow the selected recipe's `distribution_contract.asset_delivery` exactly:
    
    - `bundled-open`: allowed only with package-local source, exact hash, SPDX
      identifier, and package-local license evidence.
    - `user-supplied`: require a lawful local `--asset`; never fetch, publish, or
      commit it or the isolated staged copy.
    - `blocked`: stop. An adapter, public URL, or matching-looking asset does not
      unlock the recipe.
    
    Read [references/execution-contract.md](references/execution-contract.md) when
    adding a recipe or diagnosing a validation failure.
    
  • skills/blender-pipeline/SKILL.md4.0 KB6ad41d6c6783upstream ↗
    ---
    name: blender-pipeline
    description: Extract a tutorial or reconstruct a Blender result from video links, local videos with supporting assets, or Markdown tutorials in Codex chat. Clarify the intended output when unspecified; also route explicit showcase reproduction and independent asset edits.
    ---
    
    # Blender Pipeline
    
    ## Start from the Codex client
    
    This is the user-facing Codex launcher. If the requested output is unclear, ask
    whether the user wants only a tutorial or a complete Blender reconstruction;
    wait for their choice before launching. Do not ask again when the goal is explicit.
    
    Read [references/codex-launch.md](references/codex-launch.md), interpret the
    user's natural-language inputs, and invoke this skill's
    `scripts/launch_from_codex.py` yourself. It calls the same maintained pipeline
    as the API entrypoint. Tutorial-only stops after preparation; full reconstruction
    continues through knowledge retrieval → Blender generation → render and review.
    
    A video with an accompanying `.blend`, preview, texture, or dependency bundle
    retains those inputs in either selected route; it is not an independent edit.
    A supplied Markdown tutorial skips video extraction: prepare it for tutorial-only,
    or continue knowledge-backed generation for reconstruction. No RW1 is required.
    
    Use the user's requested output location or established data root. Ask only for
    missing information needed to run, not command-line flags or API credentials.
    The Codex path uses the signed-in Codex CLI; the user need not run a Python
    launcher manually. `run_codex.py` remains a compatibility entrypoint, not the
    client interaction. Requests to explain, inspect, or dry-run do not authorize
    an actual reconstruction.
    
    ## Extract a tutorial from video
    
    For tutorial-only, pass `--extract-only` and do not start reconstruction. Read
    [tutorial-extraction/SKILL.md](tutorial-extraction/SKILL.md) for illustrated
    Markdown, learner inputs and the separate rubric; both replay routes reuse it.
    
    ## Reproduce a maintained showcase
    
    Read [reproduction/SKILL.md](reproduction/SKILL.md) only for an explicitly
    requested catalog recipe or hybrid-delivery workflow. A tutorial's subject
    also appearing on the showcase does not change ordinary replay routing.
    Public previews do not authorize downloading the underlying assets.
    
    ## Generate from zero
    
    For ordinary video/tutorial requests use the client launcher above. Use the
    specialized generation mode for an explicit from-zero reference/text task or
    low-level generation work, with no authoritative starting project.
    
    Read [generation/SKILL.md](generation/SKILL.md), then load
    [knowledge/generation.md](knowledge/generation.md),
    [knowledge/evidence-and-routing.md](knowledge/evidence-and-routing.md), and only
    the relevant sections of
    [knowledge/rendering-and-dynamics.md](knowledge/rendering-and-dynamics.md).
    
    ## Edit an existing asset
    
    Use editing for a standalone change request on an existing asset, without a
    video/tutorial reconstruction workflow. A generated replacement object within
    that scoped change remains part of the edit.
    
    Read [editing/SKILL.md](editing/SKILL.md), then load
    [knowledge/editing.md](knowledge/editing.md) and only the relevant sections of
    [knowledge/rendering-and-dynamics.md](knowledge/rendering-and-dynamics.md).
    
    ## Shared rules
    
    - Keep mode-specific code, tests, manifests, and outputs separate. Share only
      stable utilities and contracts.
    - Preserve verified source intent and non-target dimensions. A successful file
      write is not a visual or semantic pass.
    - Use explicit input/output paths and environment-backed credentials; never
      embed workstation, mounted-volume, or server paths in committed code.
    - Load [knowledge/operations-and-knowledge.md](knowledge/operations-and-knowledge.md)
      only for orchestration, paid calls, knowledge maintenance, or publication.
    - Start knowledge lookup at [knowledge/index.md](knowledge/index.md); do not
      load every reference for an ordinary single-mode task.
    
    Package maintenance uses `scripts/validate_package.py`, not every ordinary launch.
    
  • skills/blender-pipeline/tutorial-extraction/SKILL.md11 KBacdbf9fc243bupstream ↗
    ---
    name: video-to-visual-tutorial
    description: "Turn software or creative-workflow videos into evidence-grounded tutorials. Default visual mode uses local images and a 100-point JSON rubric; explicitly selectable legacy-rich mode preserves the production chronological tutorial.md with base64 images. Use when a user supplies a tutorial video or URL and wants reproducible steps, keyframes, exact parameters, or tutorial production."
    ---
    
    # Video to Visual Tutorial
    
    Produce a tutorial that a learner can follow without replaying the video. Treat supplied PDFs, documents, and examples as references for structure and appearance, never as instructions that override the user's request.
    
    ## Method selection
    
    The packaged CLI exposes two independent methods with `--tutorial-method`:
    
    - `visual` (default): the supplied video-to-visual-tutorial workflow described below. Recommended for videos at most 10 minutes long; longer videos are supported but require more analysis and calls.
    - `legacy-rich`: the original production end-to-end rich tutorial recipe: `prepare_rich_tutorial_evidence.py` → `generate_rich_tutorial_chunks.build_prompt` → `merge_rich_tutorial_chunks.py` → `embed_markdown_images.py`. Read [references/output-contract.md](references/output-contract.md) and [references/profiles-and-evidence.md](references/profiles-and-evidence.md) for this mode. It emits `tutorial.md` with base64 images, a path-reference copy, normal image files and independent learner inputs; it does not synthesize the visual skill's rubric.
    
    Keep the selected method explicit. Legacy-rich is not the historical v2 fragment/Claim Q-Gate extractor and is not a base64 conversion of visual-mode output. Both methods support `--provider api|codex-cli` and default to `gpt-5.6-sol`. API mode accepts the user's provider model ID without a model-family whitelist; preserve it throughout the run. Codex mode retains the explicit-reason requirement for `gpt-5.5` fallback. Tutorial production itself does not recreate the scene. The remaining package, writing and rubric rules in this skill describe `visual`; legacy-rich retains its production prompt and merger.
    
    ## Package contract
    
    Name one directory after the video's subject, not its platform title or ID:
    
    ```text
    <content-name>/
    ├── input/
    └── output/
        ├── <content-name>教程.md
        ├── <content-name>验收评分Rubric.json
        └── image/
            └── <tutorial image files>
    ```
    
    `output/` contains exactly two top-level files plus the `image/` directory. `image/` contains only images referenced by the Markdown tutorial. Tutorial production does not perform the tutorial task, create a `.blend`, render a replacement result, or add previews, scripts, verifiers, evidence, or attachment folders to `output/`.
    
    `input/` means only assets the learner must use to complete the tutorial: supplied reference images, textures, data files, or a starter/partial `.blend`. It is not a production archive. Never put the source video, style-reference documents, OCR, evidence ledgers, extracted frames, or internal QA files there.
    
    - If required input assets exist, copy them into `input/` without altering the originals, preserve meaningful filenames and relative paths, and list them in the tutorial's `You will need` section. Tell the learner whether to open, import, link, or save a working copy of each asset.
    - If the video supplies no required assets, leave `input/` completely empty. Do not add a README or placeholder. State in `You will need` that no input asset is provided and explain the starting scene.
    - Keep source analysis and reference documents in a working cache outside the final tutorial directory.
    
    Default Blender compatibility is 4.1 and 5.1.2 unless the user specifies otherwise. Do not claim compatibility that was not checked.
    
    ## Evidence-first workflow
    
    1. Inspect any reference deliverable for hierarchy, recurring blocks, image treatment, and QA expectations. Reuse its information architecture, not its subject matter.
    2. Acquire only the source material needed for analysis. Record title, creator, stable ID or URL, duration, dimensions, and publication metadata. Do not invent a transcript when the video is driven by on-screen UI and captions.
    3. Run `scripts/prepare_video.py` on a local video to create a coarse contact sheet, timestamped frames, and optional OCR. Start at 2-second intervals for videos under 2 minutes, 5–10 seconds for medium videos, and 15–30 seconds for long videos.
    4. Inspect the contact sheet once. Open individual frames only at operation changes, parameter edits, ambiguous UI states, or final results. Increase sampling locally instead of decoding the whole video at high density.
    5. Build a compact evidence ledger using [references/evidence-ledger.md](references/evidence-ledger.md). Every exact parameter, node connection, command, and operation order must point to a timestamp/frame. Label useful additions that are not shown as `recommendation`; do not present them as video facts.
    6. Group adjacent micro-actions by learner intent. A step normally contains a time range, outcome-oriented title, concise actions, one representative frame, a visible success criterion, and one practical correction.
    7. Author the tutorial as Markdown and the rubric as JSON for different audiences. Follow [references/markdown-layout.md](references/markdown-layout.md) and [references/blender-capability-rubric.md](references/blender-capability-rubric.md).
    8. Run `scripts/validate_visual_package.py` and preview the Markdown in a renderer that resolves local relative paths. Fix broken image references, unreadable screenshots, mismatched captions, unsupported claims, invalid JSON, scoring gaps, and verifier mismatches before delivery.
    
    ## Tutorial writing rules
    
    - Include a visible `You will need` section near the start. State the supported Blender versions and only the assets the learner actually receives in `input/`. If `input/` is empty, say so plainly and name the starting scene.
    - Preserve operation order. For Blender, independently verify modifier order, node wiring, and numeric fields; visually similar outcomes can come from materially different graphs.
    - Copy values from the clearest frame, not OCR alone. If a value is unreadable, give a bounded visual criterion or mark it unspecified; never manufacture precision.
    - Use the application's vocabulary. Add English UI names only when useful across localized interfaces or versions.
    - A screenshot must show the operation it accompanies. Prefer the frame after the decisive edit, with both the setting and its result visible.
    - Every tutorial image comes from the source video or a learner input asset. The first image must be an actual source-video frame, normally the clearest final-result frame. Never substitute a newly modeled or newly rendered image.
    - Copy tutorial images into `output/image/` and use Markdown image syntax with a descriptive caption and a relative target such as `image/frame_001.jpg`. Do not use absolute paths, remote image URLs, data URLs, or paths that leave `output/`.
    - Keep only referenced images in `output/image/`; do not use that directory as an evidence dump.
    - Tutorial production is documentation work only. Do not open Blender to recreate the task, build a solution artifact, or render a new result unless the user separately requests that work.
    - Write as a practical human instructor. Avoid promotional filler, synthetic summaries, and decorative claims such as “7 steps · images and natural language · no code.” Do not expose internal taxonomy tags in the tutorial unless they help the learner.
    - The tutorial is given to the task-performing agent. Do not mention the rubric, verifier, check IDs, grading thresholds, hidden solution files, or production-side evidence in it.
    - Keep `shown`, `inferred`, and `recommendation` distinct in the evidence ledger. Only `shown` claims may be phrased as exact facts from the video.
    
    ## Scoring and artifact verification
    
    - The rubric totals exactly 100 points and is emitted as UTF-8 JSON.
    - Use only these eight capability labels: `GEO`, `PROC`, `SURF`, `SCN`, `RIG`, `ANM`, `SIM`, `PIPE`.
    - Include only capabilities and rows that actually receive points. Do not list unused labels or reproduce the full taxonomy in each rubric.
    - Every scored row has a unique check ID, point value, observable acceptance rule, and matching artifact verifier check. A label without a verifier is not scored.
    - The verifier reports `PASS`, `PARTIAL`, or `FAIL`, worth 100%, 50%, or 0% of that row unless the rubric explicitly defines another deterministic mapping.
    - Because `output/` may contain only the tutorial, rubric, and tutorial images, embed the non-destructive Blender Python verifier source inside the rubric JSON. It must inspect the future submitted `.blend`, produce a JSON score report, and work in both 4.1 and 5.1.2 when feasible.
    - Never award points solely from screenshots, prose, or filenames when the underlying `.blend` state is inspectable.
    - The grading JSON contains only scoring metadata, scored rows, category totals, status weights, and the embedded artifact verifier. It contains no checklist, learner instructions, human-review section, grading record, unused capability labels, or general capability catalog.
    
    ## Token-efficient batch behavior
    
    - Reuse metadata, contact sheets, OCR, evidence ledgers, crop coordinates, document styles, and rubric templates across retries. Do not repeatedly inspect the raw video.
    - Keep raw OCR out of the writing context after claims are resolved; the ledger is the source of truth.
    - Use one representative image per step unless a before/after comparison is essential.
    - Generate the Markdown tutorial, its copied image assets, and JSON rubric in one build pass. Preview only the Markdown sections whose images or layout need inspection.
    - Validate check IDs and points programmatically. Spend model attention on ambiguous evidence and visual QA, not deterministic arithmetic.
    - Stop expanding once every distinct user-visible operation, exact value, success criterion, attachment, and final check is covered.
    
    ## Deliverables
    
    Return the tutorial directory with an empty or correctly populated `input/`, exactly two top-level files under `output/` (the Markdown tutorial and JSON rubric), and an `output/image/` directory containing only tutorial images. Preserve source attribution in the tutorial, but do not include the source video, reference documents, generated Blender files, rendered results, evidence, or production helpers in the final directory unless a source asset is itself a required learner input.
    
    ## Pipeline entrypoint
    
    For the packaged CLI, use `scripts/extract_video_tutorial.py`; read
    [references/output-contract.md](references/output-contract.md) for input assets,
    workspace integration, optional HTML, and existing generation/reproduction callers.
    The CLI defaults to this visual skill and also preserves the independently
    selectable production `legacy-rich` recipe. Neither method invokes the legacy
    v2 fragment extractor.
    Read [references/profiles-and-evidence.md](references/profiles-and-evidence.md)
    when selecting cost and sampling settings.
    
  • skills/blender-pipeline/scripts/inspect_input_asset.py6.3 KB23454ef09243upstream ↗
    """Trusted Blender-side, non-saving inspection of a staged source asset."""
    
    import argparse
    import hashlib
    import json
    import re
    import sys
    from pathlib import Path
    
    import bpy
    
    
    def image_dependency_paths(item, path: Path) -> list[Path]:
        """Resolve declared UDIM tiles, rather than looking for a literal token."""
        if item.source != "TILED":
            return [path]
        tiles = list(item.tiles)
        if not tiles:
            return [path]
        value = str(path)
        result = []
        for tile in tiles:
            number = int(tile.number)
            if "<UDIM>" in value:
                target = value.replace("<UDIM>", str(number))
            elif "<UVTILE>" in value:
                target = value.replace(
                    "<UVTILE>", f"u{(number - 1001) % 10 + 1}_v{(number - 1001) // 10 + 1}"
                )
            else:
                # Blender may retain the first concrete tile name instead of a
                # token. Replace only a standalone conventional four-digit tile ID.
                target, count = re.subn(
                    r"(?<!\d)1\d{3}(?!\d)(?=[^/\\]*$)", str(number), value, count=1
                )
                if not count and len(tiles) > 1:
                    return []
            result.append(Path(target).resolve())
        return result
    
    
    def mesh_topology_summary(mesh) -> dict:
        """Describe the stored mesh without welding vertices or applying modifiers."""
        face_uses = [0] * len(mesh.edges)
        for polygon in mesh.polygons:
            for loop_index in polygon.loop_indices:
                face_uses[mesh.loops[loop_index].edge_index] += 1
        positions = set()
        coincident = 0
        for vertex in mesh.vertices:
            position = tuple(vertex.co)
            if position in positions:
                coincident += 1
            else:
                positions.add(position)
        return {
            "vertices": len(mesh.vertices),
            "edges": len(mesh.edges),
            "faces": len(mesh.polygons),
            "boundary_edges": sum(count == 1 for count in face_uses),
            "nonmanifold_edges": sum(count != 2 for count in face_uses),
            "coincident_vertex_count": coincident,
        }
    
    
    def inspect(asset: Path, root: Path) -> dict:
        if asset.suffix.lower() != ".blend":
            # Interchange files do not replace the current scene. Factory startup
            # contains a cube, camera and lamp that must not become source assets.
            bpy.ops.wm.read_factory_settings(use_empty=True)
        if asset.suffix.lower() == ".blend":
            bpy.ops.wm.open_mainfile(filepath=str(asset), load_ui=False, use_scripts=False)
        elif asset.suffix.lower() == ".fbx":
            bpy.ops.import_scene.fbx(filepath=str(asset))
        elif asset.suffix.lower() in {".glb", ".gltf"}:
            bpy.ops.import_scene.gltf(filepath=str(asset))
        elif asset.suffix.lower() == ".obj":
            bpy.ops.wm.obj_import(filepath=str(asset))
        issues = []
        images = []
        for item in bpy.data.images:
            if item.source not in {"FILE", "TILED", "SEQUENCE", "MOVIE"}:
                continue
            packed = bool(item.packed_file or item.packed_files)
            path = Path(bpy.path.abspath(item.filepath, library=item.library)).resolve()
            dependencies = image_dependency_paths(item, path) if not packed else []
            if not packed and (
                not dependencies
                or any(not p.is_file() or not p.is_relative_to(root) for p in dependencies)
            ):
                issues.append(
                    f"Image dependency is missing or outside the staged bundle: {item.name}"
                )
            images.append(
                {
                    "name": item.name,
                    "packed": packed,
                    "path": str(path) if not packed else None,
                    "tile_paths": [str(p) for p in dependencies]
                    if item.source == "TILED"
                    else [],
                }
            )
        for lib in bpy.data.libraries:
            path = Path(bpy.path.abspath(lib.filepath)).resolve()
            if not path.is_file() or not path.is_relative_to(root):
                issues.append(
                    f"Linked library is missing or outside the staged bundle: {lib.name}"
                )
        for material in bpy.data.materials:
            if material.use_nodes and material.node_tree:
                if any(n.bl_idname == "NodeUndefined" for n in material.node_tree.nodes):
                    issues.append(f"Unsupported shader node in material: {material.name}")
        return {
            "schema": "blender-pipeline-input-audit.v1",
            "selected_model_sha256": hashlib.file_digest(
                asset.open("rb"), "sha256"
            ).hexdigest()
            if hasattr(hashlib, "file_digest")
            else hashlib.sha256(asset.read_bytes()).hexdigest(),
            "status": "blocked" if issues else "pass",
            "issues": issues,
            "blender_version": bpy.app.version_string,
            "topology_fact_definitions": {
                "scope": "Stored mesh, before modifier evaluation; no topology was changed.",
                "boundary_edges": "Edges incident to exactly one polygon.",
                "nonmanifold_edges": "Edges incident to other than two polygons, including boundary and loose edges.",
                "coincident_vertex_count": "Vertices beyond the first at exactly identical object-local coordinates; no tolerance-based merging is inferred.",
            },
            "objects": [
                {
                    "name": o.name,
                    "type": o.type,
                    **(
                        mesh_topology_summary(o.data)
                        if o.type == "MESH"
                        else {"vertices": None}
                    ),
                    "materials": [m.name if m else None for m in o.data.materials]
                    if hasattr(o.data, "materials")
                    else [],
                    "modifiers": [m.type for m in o.modifiers],
                }
                for o in bpy.context.scene.objects
            ],
            "images": images,
            "frame_range": [bpy.context.scene.frame_start, bpy.context.scene.frame_end],
        }
    
    
    if __name__ == "__main__":
        parser = argparse.ArgumentParser()
        parser.add_argument("--asset", type=Path, required=True)
        parser.add_argument("--root", type=Path, required=True)
        parser.add_argument("--output", type=Path, required=True)
        args = parser.parse_args(sys.argv[sys.argv.index("--") + 1 :])
        result = inspect(args.asset.resolve(), args.root.resolve())
        args.output.write_text(
            json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8"
        )
        if result["issues"]:
            raise RuntimeError("; ".join(result["issues"]))
    
  • skills/blender-pipeline/scripts/launch_from_codex.py412 Bac42512641b3upstream ↗
    #!/usr/bin/env python3
    """Run the shared reproduction pipeline from the selectable Codex skill."""
    
    import sys
    from pathlib import Path
    
    sys.dont_write_bytecode = True
    sys.path.insert(0, str(Path(__file__).resolve().parent))
    
    import pipeline_launcher
    
    
    def main(argv: list[str] | None = None) -> int:
        return pipeline_launcher.main("codex-cli", argv)
    
    
    if __name__ == "__main__":
        raise SystemExit(main())
    
  • skills/blender-pipeline/scripts/pipeline_launcher.py31 KB3c50e923aa17upstream ↗
    """Portable, explicit-input entry point to the maintained replay pipeline.
    
    Dataset acquisition, showcase recipe enablement, and knowledge promotion are
    deliberately not launcher responsibilities.
    """
    
    from __future__ import annotations
    
    import argparse
    import getpass
    import hashlib
    import importlib.util
    import json
    import os
    import shutil
    import subprocess
    import sys
    from pathlib import Path
    from urllib.parse import urlparse
    
    HERE = Path(__file__).resolve().parent
    PIPELINE = HERE.parent
    REPO = PIPELINE.parent.parent
    GENERATION = PIPELINE / "generation/scripts"
    EXTRACTION = PIPELINE / "tutorial-extraction/scripts"
    MODEL_FORMATS = {".blend", ".glb", ".gltf", ".obj", ".fbx"}
    IMAGE_FORMATS = {".png", ".jpg", ".jpeg", ".webp", ".tif", ".tiff", ".exr", ".hdr"}
    
    
    def digest(path: Path) -> str:
        result = hashlib.sha256()
        with path.open("rb") as stream:
            for block in iter(lambda: stream.read(1024 * 1024), b""):
                result.update(block)
        return result.hexdigest()
    
    
    def write_json(path: Path, value: object) -> None:
        path.write_text(
            json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
        )
    
    
    def parser(provider: str) -> argparse.ArgumentParser:
        p = argparse.ArgumentParser(
            description=f"Tutorial → knowledge-assisted Blender reproduction ({provider}). No RW1 dataset required."
        )
        p.add_argument(
            "--config",
            type=Path,
            help="JSON config; CLI overrides config, then environment",
        )
        p.add_argument(
            "--configure",
            action="store_true",
            help="API only: interactively create private endpoint/key configuration outside the repository",
        )
        source = p.add_mutually_exclusive_group()
        source.add_argument("--video-file", type=Path)
        source.add_argument("--video-url")
        source.add_argument(
            "--tutorial",
            type=Path,
            help="Existing Markdown tutorial with numbered operation headings and local/base64 images",
        )
        p.add_argument("--title", help="Tutorial title; defaults to the input filename")
        p.add_argument(
            "--asset",
            type=Path,
            help="Authoritative starting .blend/.glb/.gltf/.obj/.fbx; never overwritten",
        )
        p.add_argument(
            "--asset-root",
            type=Path,
            help="Optional authorized dependency bundle root containing --asset; copies this complete directory",
        )
        p.add_argument(
            "--input-asset",
            type=Path,
            action="append",
            default=[],
            help="Supporting texture/file/directory, repeatable",
        )
        p.add_argument(
            "--preview",
            type=Path,
            action="append",
            default=[],
            help="Input/starting-state preview, not the final target; repeatable",
        )
        p.add_argument(
            "--target-image",
            type=Path,
            help="Optional finished-result reference, distinct from --preview",
        )
        p.add_argument(
            "--output-dir",
            type=Path,
            help="New empty run directory outside the repository (required)",
        )
        p.add_argument(
            "--tutorial-method", choices=("visual", "legacy-rich"), default="visual"
        )
        p.add_argument(
            "--profile", choices=("economy", "balanced", "forensic"), default="balanced"
        )
        p.add_argument(
            "--model",
            choices=("gpt-5.6-sol", "gpt-5.5") if provider == "codex-cli" else None,
            help="API: provider model ID; overrides the model saved in --config",
        )
        p.add_argument(
            "--fallback-reason",
            default="",
            help="Codex only: required when selecting gpt-5.5 after sol is unavailable; optional API annotation",
        )
        p.add_argument("--transcript", type=Path)
        p.add_argument("--asr-language", default="auto")
        p.add_argument(
            "--render-html",
            action="store_true",
            help="Also render a human-readable tutorial; no extra model call",
        )
        p.add_argument(
            "--extract-only",
            action="store_true",
            help="Stop after tutorial preparation, before Blender generation",
        )
        p.add_argument(
            "--max-extraction-calls",
            type=int,
            help="Hard total extraction-call cap, including repair",
        )
        p.add_argument(
            "--max-replay-calls",
            type=int,
            default=8,
            help="Codegen and visual review call cap (default: 8)",
        )
        p.add_argument(
            "--max-replay-tokens",
            type=int,
            default=500000,
            help="Replay ledger token reservation cap",
        )
        p.add_argument(
            "--repair-attempts",
            type=int,
            choices=(1, 2, 3),
            default=2,
            help="Total replay attempts, including the initial attempt",
        )
        p.add_argument("--blender", help="Blender executable path")
        p.add_argument(
            "--endpoint", help="API only: credential-free HTTPS Chat Completions endpoint"
        )
        p.add_argument(
            "--api-key-file",
            type=Path,
            help="API only: private key file outside repository; POSIX mode 0600",
        )
        p.add_argument(
            "--check",
            action="store_true",
            help="One small real model request plus local executable checks; does not claim asset reproduction",
        )
        p.add_argument(
            "--dry-run",
            action="store_true",
            help="Print the execution plan; no writes, downloads, credential reads, or model calls",
        )
        return p
    
    
    def existing(path: Path, *, directory: bool = False) -> Path:
        resolved = path.expanduser().resolve(strict=True)
        if not (resolved.is_dir() if directory else resolved.is_file()):
            raise ValueError(f"Not a {'directory' if directory else 'file'}: {path}")
        return resolved
    
    
    def external(path: Path) -> Path:
        path = path.expanduser().resolve()
        if path == REPO or path.is_relative_to(REPO):
            raise ValueError(
                "Run outputs and private configuration must be outside the code repository"
            )
        return path
    
    
    def endpoint_url(value: str) -> str:
        p = urlparse(value)
        if (
            p.scheme != "https"
            or not p.netloc
            or p.username
            or p.password
            or p.query
            or p.fragment
        ):
            raise ValueError(
                "Use a credential-free HTTPS Chat Completions endpoint (no query/fragment)"
            )
        if not p.path.rstrip("/").endswith("/chat/completions"):
            raise ValueError("Endpoint must end with /chat/completions")
        return value.rstrip("/")
    
    
    def model_id(value: str) -> str:
        """Validate a provider ID without substituting or rewriting the selection."""
        if (
            not isinstance(value, str)
            or not value
            or value != value.strip()
            or len(value) > 256
            or not all(character.isprintable() for character in value)
        ):
            raise ValueError(
                "Model must be a nonempty single-line provider ID (up to 256 characters)"
            )
        return value
    
    
    def configure(args: argparse.Namespace, provider: str) -> int:
        if provider != "api" or not args.config:
            raise ValueError(
                "Use run_api.py --configure --config /private/path/pipeline.json"
            )
        dest = external(args.config)
        key_path = dest.parent / "model_api_key"
        if dest.exists() or key_path.exists():
            raise ValueError(
                "Configuration/key already exists; choose a new location or edit your existing configuration"
            )
        endpoint = endpoint_url(input("HTTPS Chat Completions endpoint: ").strip())
        key = getpass.getpass("API key (hidden): ").strip()
        if not key or "\n" in key:
            raise ValueError("An API key is required")
        model = model_id(
            args.model
            if args.model is not None
            else input("Model [gpt-5.6-sol]: ").strip() or "gpt-5.6-sol"
        )
        dest.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
        created = []
    
        def write_private(path: Path, content: str) -> None:
            fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
            created.append(path)
            with os.fdopen(fd, "w", encoding="utf-8") as stream:
                metadata = os.fstat(stream.fileno())
                if os.name == "posix" and (
                    metadata.st_mode & 0o777 != 0o600 or metadata.st_uid != os.getuid()
                ):
                    raise ValueError(
                        "Private configuration requires owner-only POSIX mode 0600. "
                        "Choose a private local configuration directory on a filesystem "
                        "that supports these permissions, not exFAT."
                    )
                stream.write(content)
    
        try:
            write_private(key_path, key)
            write_private(
                dest,
                json.dumps(
                    {
                        "endpoint": endpoint,
                        "api_key_file": str(key_path),
                        "model": model,
                    },
                    ensure_ascii=False,
                    indent=2,
                )
                + "\n",
            )
        except BaseException:
            # Roll back only files exclusively created by this invocation. Never
            # report a usable configuration when its filesystem ignored 0600.
            for path in reversed(created):
                path.unlink(missing_ok=True)
            raise
        print(f"Private configuration created: {dest}")
        return 0
    
    
    def settings(args: argparse.Namespace, provider: str) -> dict:
        config = json.loads(existing(args.config).read_text()) if args.config else {}
        if not isinstance(config, dict) or set(config) - {
            "endpoint",
            "api_key_file",
            "model",
            "blender",
        }:
            raise ValueError(
                "Config supports only endpoint, api_key_file, model, blender; never put an inline API key in it"
            )
        if any(
            not isinstance(value, str) or not value.strip() for value in config.values()
        ):
            raise ValueError("Every configuration value must be a nonempty string")
        model = model_id(
            args.model if args.model is not None else config.get("model", "gpt-5.6-sol")
        )
        if provider == "codex-cli":
            if model not in {"gpt-5.6-sol", "gpt-5.5"}:
                raise ValueError(
                    "Codex model must be gpt-5.6-sol, or explicit gpt-5.5 fallback"
                )
            if (model == "gpt-5.5") != bool(args.fallback_reason.strip()):
                raise ValueError(
                    "gpt-5.5 requires --fallback-reason; omit that reason for gpt-5.6-sol"
                )
        if args.max_replay_calls < 1 or args.max_replay_tokens < 1:
            raise ValueError("Replay budgets must be positive")
        if args.max_extraction_calls is not None and args.max_extraction_calls < 1:
            raise ValueError("--max-extraction-calls must be positive")
        endpoint = (
            args.endpoint
            or config.get("endpoint")
            or os.environ.get("BLENDER_PIPELINE_API_ENDPOINT", "")
        )
        key = (
            args.api_key_file
            or config.get("api_key_file")
            or os.environ.get("BLENDER_PIPELINE_API_KEY_FILE", "")
        )
        blender = (
            args.blender
            or config.get("blender")
            or os.environ.get("BLENDER_PIPELINE_BLENDER")
            or shutil.which("blender")
        )
        if (
            not blender
            and Path("/Applications/Blender.app/Contents/MacOS/Blender").is_file()
        ):
            blender = "/Applications/Blender.app/Contents/MacOS/Blender"
        needs_model = args.check or not (args.tutorial and args.extract_only)
        if provider == "api" and not args.dry_run and needs_model:
            endpoint = endpoint_url(endpoint)
            if not key:
                raise ValueError("API requires --config, or --endpoint and --api-key-file")
            key = external(existing(Path(key)))
            if os.name == "posix" and (key.stat().st_mode & 0o777) != 0o600:
                raise ValueError(
                    "API key file must have mode 0600; run chmod 600 on that private file"
                )
        if (
            provider == "codex-cli"
            and not args.dry_run
            and needs_model
            and not shutil.which("codex")
        ):
            raise ValueError(
                "Codex CLI is not installed/on PATH; install it and run codex login first"
            )
        if not args.dry_run and (not args.extract_only or args.asset):
            if not blender:
                raise ValueError("Blender not found; specify --blender /path/to/blender")
            blender = str(existing(Path(shutil.which(str(blender)) or blender)))
        return {
            "model": model,
            "endpoint": endpoint,
            "key": str(key),
            "blender": blender or "blender",
        }
    
    
    def check_dependencies(args: argparse.Namespace, options: dict) -> None:
        modules = ["PIL", "requests", "jsonschema"]
        if args.render_html:
            modules.append("markdown")
        absent = [name for name in modules if importlib.util.find_spec(name) is None]
        if absent:
            raise ValueError(
                "Missing Python packages: "
                + ", ".join(absent)
                + "; install requirements.txt"
            )
        if not (args.tutorial and args.extract_only and not args.check):
            for executable in ("ffmpeg", "ffprobe"):
                if not shutil.which(executable):
                    raise ValueError(
                        f"Missing {executable}; install FFmpeg and add it to PATH"
                    )
        if args.video_url and importlib.util.find_spec("yt_dlp") is None:
            raise ValueError(
                "Missing yt-dlp; install requirements.txt or supply --video-file"
            )
        if args.check:
            result = subprocess.run(
                [options["blender"], "--version"],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                timeout=20,
            )
            if result.returncode:
                raise ValueError("Configured Blender executable failed its version check")
    
    
    def safe_copy(source: Path, target: Path) -> None:
        if source.is_dir() and target.resolve().is_relative_to(source.resolve()):
            raise ValueError("Output cannot be nested inside a supporting input directory")
        if source.is_symlink() or (
            source.is_dir() and any(p.is_symlink() for p in source.rglob("*"))
        ):
            raise ValueError(
                f"Input bundle contains symlinks; supply a self-contained copy: {source}"
            )
        if target.exists():
            raise ValueError(
                f"Input name collision: {target.name}; use --asset-root to preserve a complete bundle"
            )
        target.parent.mkdir(parents=True, exist_ok=True)
        if source.is_dir():
            shutil.copytree(
                source, target, ignore=shutil.ignore_patterns("._*", ".DS_Store")
            )
        else:
            shutil.copy2(source, target)
    
    
    def command(argv: list[str], env: dict, *, log: Path | None = None) -> None:
        if log:
            with log.open("w", encoding="utf-8") as stream:
                result = subprocess.run(
                    argv, env=env, stdout=stream, stderr=subprocess.STDOUT
                )
        else:
            result = subprocess.run(argv, env=env)
        if result.returncode:
            raise RuntimeError(
                f"Stage {Path(argv[1] if argv[0] == sys.executable else argv[0]).name} exited {result.returncode}"
                + (f"; details: {log}" if log else "")
            )
    
    
    def runtime_env(
        out: Path, options: dict, provider: str, args: argparse.Namespace
    ) -> dict:
        env = os.environ.copy()
        # A new public run must not inherit a private dataset worker's path or GPU policy.
        for name in list(env):
            if name.startswith(
                (
                    "RW1_",
                    "RW2_",
                    "TOTAL_ASSET_",
                    "VIDEO_REPLAY_",
                    "BLENDER_KNOWLEDGE_",
                    "VIDEO2BLENDER_",
                    "PAPER12_",
                )
            ):
                env.pop(name)
        control = out / ".control"
        temp = control / "tmp"
        temp.mkdir(parents=True, exist_ok=True)
        env.update(
            {
                "PYTHONDONTWRITEBYTECODE": "1",
                "TMPDIR": str(temp),
                "TEMP": str(temp),
                "TMP": str(temp),
                "XDG_CACHE_HOME": str(control / "cache"),
                "HF_HOME": str(control / "cache/huggingface"),
                "TORCH_HOME": str(control / "cache/torch"),
                "MPLCONFIGDIR": str(control / "cache/matplotlib"),
                "VIDEO2BLENDER_OUTPUT_ROOT": str(out),
                "VIDEO2BLENDER_CONFIG_ROOT": str(control),
                "VIDEO2BLENDER_KEEP_TRACE_IN_PLACE": "1",
                "BLENDER_KNOWLEDGE_ROOT": str(control / "knowledge"),
                "VIDEO_REPLAY_PAID_API_LEDGER": str(control / "model_ledger.sqlite3"),
                "VIDEO_REPLAY_PAID_API_MAX_CALLS_PER_ASSET": str(args.max_replay_calls),
                "VIDEO_REPLAY_PAID_API_GLOBAL_MAX_CALLS": str(args.max_replay_calls),
                "VIDEO_REPLAY_PAID_API_MAX_TOKENS_PER_ASSET": str(args.max_replay_tokens),
                "BLENDER_PIPELINE_PROVIDER": provider,
                "BLENDER_PIPELINE_MODEL": options["model"],
                "BLENDER_PIPELINE_BLENDER": options["blender"],
                "BLENDER_PIPELINE_RENDER_DEVICE_POLICY": "local",
                "VIDEO2BLENDER_RENDER_ENGINE": "CYCLES",
                "BLENDER_PIPELINE_FILM_TRANSPARENT": os.environ.get(
                    "BLENDER_PIPELINE_FILM_TRANSPARENT", "0"
                ),
                "VIDEO2BLENDER_CYCLES_BACKEND": os.environ.get(
                    "VIDEO2BLENDER_CYCLES_BACKEND", "CPU"
                ),
                "BLENDER_PIPELINE_REPAIR_ATTEMPTS": str(args.repair_attempts - 1),
                "BLENDER_PIPELINE_VISUAL_REVIEW": "1",
            }
        )
        if provider == "api":
            env.update(
                {
                    "BLENDER_PIPELINE_API_ENDPOINT": options["endpoint"],
                    "BLENDER_PIPELINE_API_KEY_FILE": options["key"],
                    "VIDEO_REPLAY_APPROVED_PAID_API_ENDPOINT": options["endpoint"],
                }
            )
        else:
            env.pop("BLENDER_PIPELINE_API_KEY_FILE", None)
            env.pop("BLENDER_PIPELINE_API_ENDPOINT", None)
        return env
    
    
    def stage_inputs(
        args: argparse.Namespace, out: Path, title: str, env: dict, options: dict
    ) -> list[Path]:
        linked = out / "linked_source"
        linked.mkdir()
        source_asset = existing(args.asset) if args.asset else None
        staged_asset = None
        if args.asset_root:
            root = existing(args.asset_root, directory=True)
            if not source_asset or not source_asset.is_relative_to(root):
                raise ValueError("--asset-root must contain --asset")
            if out.is_relative_to(root):
                raise ValueError("Output cannot be nested inside the input bundle")
            for item in root.iterdir():
                if item.name.startswith("._") or item.name == ".DS_Store":
                    continue
                safe_copy(item, linked / item.name)
            staged_asset = linked / source_asset.relative_to(root)
        elif source_asset:
            staged_asset = linked / source_asset.name
            safe_copy(source_asset, staged_asset)
        records = []
        learner = [linked] if args.asset_root else ([staged_asset] if staged_asset else [])
        for role, paths in (("supporting", args.input_asset), ("preview", args.preview)):
            for raw in paths:
                source = raw.expanduser().resolve(strict=True)
                if (
                    role == "supporting"
                    and args.asset_root
                    and source.is_relative_to(existing(args.asset_root, directory=True))
                ):
                    target = linked / source.relative_to(
                        existing(args.asset_root, directory=True)
                    )
                else:
                    target = (
                        linked if role == "supporting" else out / "input_previews"
                    ) / source.name
                if not target.exists():
                    safe_copy(source, target)
                elif not args.asset_root or not source.is_relative_to(
                    existing(args.asset_root, directory=True)
                ):
                    raise ValueError("Duplicate input basename: " + source.name)
                if not args.asset_root or not target.is_relative_to(linked):
                    learner.append(target)
                files = sorted(target.rglob("*")) if target.is_dir() else [target]
                for path in files:
                    if (
                        path.is_file()
                        and not path.name.startswith("._")
                        and path.name != ".DS_Store"
                    ):
                        records.append(
                            {"path": str(path), "role": role, "sha256": digest(path)}
                        )
        # List the bundle's packed/external image assets even if no --input-asset was needed.
        for path in sorted(linked.rglob("*")):
            if (
                path.is_file()
                and not path.name.startswith("._")
                and path.suffix.lower() in IMAGE_FORMATS
                and str(path) not in {r["path"] for r in records}
            ):
                records.append(
                    {"path": str(path), "role": "supporting", "sha256": digest(path)}
                )
        write_json(
            out / "input_assets.json",
            {"schema": "blender-pipeline-input-assets.v1", "assets": records},
        )
        info = {
            "title": title,
            "source_kind": "video_replay_type2" if source_asset else "video_replay",
            "webpage_url": args.video_url or "",
            "tutorial_input_assets": [str(p) for p in learner],
        }
        if args.video_file:
            info["source_video_path"] = str(existing(args.video_file))
        if staged_asset:
            config = {
                "selected_model_relative": staged_asset.relative_to(linked).as_posix(),
                "selected_model": str(staged_asset),
                "selected_model_sha256": digest(staged_asset),
            }
            info["linked_source"] = config
            write_json(out / "linked_source.json", config)
            command(
                [
                    options["blender"],
                    "--background",
                    "--factory-startup",
                    "--disable-autoexec",
                    "--python",
                    str(HERE / "inspect_input_asset.py"),
                    "--",
                    "--asset",
                    str(staged_asset),
                    "--root",
                    str(linked),
                    "--output",
                    str(out / "linked_asset_audit.json"),
                ],
                env,
                log=out / ".control/input_asset_inspection.log",
            )
            audit = json.loads((out / "linked_asset_audit.json").read_text())
            if audit.get("status") != "pass":
                raise ValueError(
                    "Input asset has missing dependencies: " + "; ".join(audit["issues"])
                )
        if args.target_image:
            from PIL import Image
    
            Image.open(existing(args.target_image)).convert("RGB").save(
                out / "final_reference.png"
            )
        write_json(out / "source.info.json", info)
        return learner
    
    
    def model_check(out: Path, env: dict, options: dict, provider: str) -> None:
        # The check uses the exact replay transport, not a separate undocumented API path.
        code = """import json, os, sys
    from pathlib import Path
    from video_replay_model_client import call_chat_completions, read_paid_api_secret
    provider=os.environ['BLENDER_PIPELINE_PROVIDER']
    r=call_chat_completions(video_dir=Path(sys.argv[1]),stage='codegen',stage_key='startup-check',prompt_version='startup-check-v1',endpoint=os.environ.get('BLENDER_PIPELINE_API_ENDPOINT',''),api_key=read_paid_api_secret(Path(os.environ['BLENDER_PIPELINE_API_KEY_FILE'])) if provider=='api' else '',model=os.environ['BLENDER_PIPELINE_MODEL'],payload={'model':os.environ['BLENDER_PIPELINE_MODEL'],'messages':[{'role':'user','content':'Reply exactly: PIPELINE_READY'}],'max_tokens':100,'reasoning_effort':'low'},timeout=(30,120))
    if r.status_code >= 400: raise RuntimeError('Provider rejected startup check: HTTP '+str(r.status_code))
    body=r.json(); answer=body['choices'][0]['message']['content']
    if 'PIPELINE_READY' not in answer: raise RuntimeError('Unexpected startup response')
    print(json.dumps({'provider':provider,'model':os.environ['BLENDER_PIPELINE_MODEL'],'response':'PIPELINE_READY'},ensure_ascii=False))
    """
        process_env = dict(env)
        process_env["PYTHONPATH"] = (
            str(GENERATION) + os.pathsep + process_env.get("PYTHONPATH", "")
        )
        command([sys.executable, "-c", code, str(out)], process_env)
    
    
    def execute(provider: str, argv: list[str] | None) -> int:
        args = parser(provider).parse_args(argv)
        if args.configure:
            if args.dry_run:
                raise ValueError(
                    "--configure cannot be combined with --dry-run; no configuration was written"
                )
            return configure(args, provider)
        if not args.output_dir:
            raise ValueError(
                "--output-dir is required; choose a data disk, not the repository"
            )
        if not args.check and not any((args.video_file, args.video_url, args.tutorial)):
            raise ValueError("Supply exactly one of --video-file, --video-url, --tutorial")
        for path in (
            args.video_file,
            args.tutorial,
            args.asset,
            args.target_image,
            args.transcript,
            *args.preview,
        ):
            if path:
                existing(path)
        if args.asset and args.asset.suffix.lower() not in MODEL_FORMATS:
            raise ValueError("--asset supports .blend, .glb, .gltf, .obj, .fbx")
        if args.asset_root and not args.asset:
            raise ValueError("--asset-root requires --asset")
        if args.asset_root:
            bundle = existing(args.asset_root, directory=True)
            if not existing(args.asset).is_relative_to(bundle):
                raise ValueError("--asset-root must contain --asset")
        for path in args.input_asset:
            resolved = path.expanduser().resolve(strict=True)
            if not (resolved.is_file() or resolved.is_dir()):
                raise ValueError("Supporting inputs must be regular files or directories")
        for path in (*args.preview, *([args.target_image] if args.target_image else [])):
            if path.suffix.lower() not in IMAGE_FORMATS:
                raise ValueError("Preview/target inputs must be supported image files")
        if args.tutorial and args.tutorial.suffix.lower() != ".md":
            raise ValueError(
                "--tutorial currently accepts Markdown (.md), not HTML/PDF/DOCX"
            )
        if args.video_url:
            video_url = urlparse(args.video_url)
            if (
                video_url.scheme != "https"
                or not video_url.netloc
                or video_url.username
                or video_url.password
            ):
                raise ValueError("Video URL must be a credential-free HTTPS URL")
        options = settings(args, provider)
        out = external(args.output_dir)
        if out.exists() and not out.is_dir():
            raise ValueError("--output-dir must name a directory, not an existing file")
        title = (
            args.title or (args.video_file or args.tutorial or Path("video_tutorial")).stem
        )
        plan = {
            "provider": provider,
            "model": options["model"],
            "tutorial_method": "provided" if args.tutorial else args.tutorial_method,
            "title": title,
            "output_dir": str(out),
            "input_project": str(args.asset) if args.asset else None,
            "supporting_inputs": [str(p) for p in args.input_asset],
            "input_previews": [str(p) for p in args.preview],
            "target_image": str(args.target_image) if args.target_image else None,
            "rw1_required": False,
            "knowledge_backend": "bundled reviewed guidance + run-local manifest_lexical",
            "stages": ["input staging", "tutorial preparation"]
            + (
                []
                if args.extract_only
                else [
                    "knowledge retrieval",
                    "existing strict Blender replay",
                    "route-specific review",
                ]
            ),
            "extract_only": args.extract_only,
            "max_extraction_calls": args.max_extraction_calls,
            "max_replay_calls": args.max_replay_calls,
            "max_replay_tokens": args.max_replay_tokens,
        }
        if args.dry_run:
            print(json.dumps(plan, ensure_ascii=False, indent=2))
            return 0
        check_dependencies(args, options)
        if out.exists() and any(out.iterdir()):
            raise ValueError(
                "Output directory must be new/empty; previous results are never silently overwritten"
            )
        out.mkdir(parents=True, exist_ok=True)
        env = runtime_env(out, options, provider, args)
        write_json(out / "launch_manifest.json", plan)
        if args.check:
            model_check(out, env, options, provider)
            return 0
        learner = stage_inputs(args, out, title, env, options)
        if args.tutorial:
            from provided_tutorial import stage
    
            tutorial_manifest = stage(
                existing(args.tutorial), out, render_html=args.render_html
            )
            if (
                not args.extract_only
                and not args.target_image
                and not tutorial_manifest["images"]
            ):
                raise ValueError(
                    "Full replay needs tutorial images or --target-image for visual comparison. "
                    "An input-state --preview is not a finished-result reference. "
                    "Use --extract-only to prepare a text-only tutorial without replay."
                )
        else:
            cmd = [
                sys.executable,
                str(EXTRACTION / "extract_video_tutorial.py"),
                "--video-file" if args.video_file else "--video-url",
                str(existing(args.video_file)) if args.video_file else args.video_url,
                "--title",
                title,
                "--output-dir",
                str(out),
                "--workspace-mode",
                "--provider",
                provider,
                "--model",
                options["model"],
                "--tutorial-method",
                args.tutorial_method,
                "--profile",
                args.profile,
                "--asr-language",
                args.asr_language,
                "--cache-dir",
                str(out.parent / ".video-tutorial-cache" / out.name),
            ]
            for item in learner:
                cmd.extend(["--input-asset", str(item)])
            if args.transcript:
                cmd.extend(["--transcript", str(existing(args.transcript))])
            if args.fallback_reason:
                cmd.extend(["--fallback-reason", args.fallback_reason])
            if args.max_extraction_calls is not None:
                cmd.extend(["--max-calls", str(args.max_extraction_calls)])
            if args.render_html:
                cmd.append("--render-html")
            command(cmd, env, log=out / ".control/tutorial_extraction.log")
        if args.extract_only:
            print(f"Tutorial ready: {out / 'tutorial.md'}")
            return 0
        command(
            [
                sys.executable,
                str(GENERATION / "build_blender_knowledge_index.py"),
                "--manifest-only",
            ],
            env,
            log=out / ".control/knowledge_index.log",
        )
        command(
            [
                sys.executable,
                str(GENERATION / "run_video_replay_main.py"),
                "--video-dir",
                str(out),
                "--out-name",
                "replay",
                "--skip-knowledge-update",
                "--workflow-evidence",
                "off",
            ],
            env,
            log=out / ".control/reproduction.log",
        )
        review = json.loads((out / "pipeline_review.json").read_text())
        if review.get("status") != "pass":
            print(
                f"Generated result needs review; it is not an accepted reproduction: {out / 'pipeline_review.json'}"
            )
            return 2
        print(f"Reproduction passed its current route checks: {out / 'asset.blend'}")
        return 0
    
    
    def main(provider: str, argv: list[str] | None = None) -> int:
        try:
            return execute(provider, argv)
        except (
            ValueError,
            OSError,
            RuntimeError,
            ImportError,
            subprocess.TimeoutExpired,
        ) as exc:
            # Do not dump configuration, environment, or provider response bodies.
            print(f"Pipeline stopped: {exc}", file=sys.stderr)
            return 1
    
  • skills/blender-pipeline/scripts/provided_tutorial.py11 KB64f2ca28a7d5upstream ↗
    """Source-preserving Markdown adapter; no model-invented steps or parameters."""
    
    from __future__ import annotations
    
    import base64
    import hashlib
    import json
    import re
    from pathlib import Path
    from urllib.parse import unquote
    
    SCHEMA = "video2blender-provided-tutorial.v1"
    DESTINATION = r"(<[^>\n]+>|(?:\\.|[^()\s\\])+)"
    TITLE = r"""("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))"""
    IMAGE = re.compile(
        r"!\[([^\]\n]*)\]\(\s*" + DESTINATION + r"(?:[ \t]+" + TITLE + r")?[ \t]*\)"
    )
    REFERENCE = re.compile(r"!\[([^\]\n]*)\](?:\[([^\]\n]*)\])?")
    DEFINITION = re.compile(
        r"^[ ]{0,3}\[([^\]\n]+)\]:[ \t]*"
        + DESTINATION
        + r"(?:[ \t]+"
        + TITLE
        + r")?[ \t]*$",
        re.M,
    )
    STEP = re.compile(
        r"^#{1,6}[ \t]+((?:步骤\s*|Step\s*)?\d+[.、::)\s].*|步骤\s*\d+.*|Step\s*\d+.*)$",
        re.M | re.I,
    )
    ORDERED_ITEM = re.compile(r"^[0-9]{1,9}[.)][ \t]+[^\n]*$", re.M)
    HEADING = re.compile(r"^#{1,6}[ \t]+[^\n]*$", re.M)
    RICH_SECTION = re.compile(r"^##[ \t]+分段图文教程[ \t]*$", re.M)
    
    
    def sha(path: Path) -> str:
        digest = hashlib.sha256()
        with path.open("rb") as stream:
            for block in iter(lambda: stream.read(1024 * 1024), b""):
                digest.update(block)
        return digest.hexdigest()
    
    
    def markdown_mask(text: str) -> str:
        """Preserve offsets but hide code examples from heading/image discovery."""
        lines, fence = [], None
        for line in text.splitlines(keepends=True):
            marker = re.match(r"^ {0,3}(`{3,}|~{3,})", line)
            hidden = fence is not None or marker is not None
            if marker:
                value = marker[1]
                if fence is None:
                    fence = value
                elif (
                    value[0] == fence[0]
                    and len(value) >= len(fence)
                    and not line[marker.end() :].strip()
                ):
                    fence = None
            lines.append(re.sub(r"[^\n]", " ", line) if hidden else line)
        masked = "".join(lines)
        return re.sub(r"(`+)([^\n]*?)\1", lambda m: " " * len(m[0]), masked)
    
    
    def reference_key(value: str) -> str:
        return " ".join(value.split()).casefold()
    
    
    def operation_spans(text: str) -> tuple[str, list[tuple[int, int]]]:
        """Project source operations without synthesizing headings or timestamps."""
        masked = markdown_mask(text)
        markers = list(STEP.finditer(masked))
        if markers:
            return "numbered_headings", [
                (m.start(), markers[i + 1].start() if i + 1 < len(markers) else len(text))
                for i, m in enumerate(markers)
            ]
        start, end = 0, len(text)
        rich = RICH_SECTION.search(masked)
        if rich:
            start = rich.end()
            boundary = re.compile(r"^#{1,2}[ \t]+", re.M).search(masked, start)
            if boundary:
                end = boundary.start()
        markers = [
            m
            for m in ORDERED_ITEM.finditer(masked, start, end)
            if re.sub(r"^[0-9]{1,9}[.)][ \t]+", "", text[m.start() : m.end()]).strip()
        ]
        spans = []
        for index, marker in enumerate(markers):
            stop = markers[index + 1].start() if index + 1 < len(markers) else end
            # A following window, contract or summary heading is not part of the
            # preceding numbered operation. Full context remains in tutorial.md.
            boundary = HEADING.search(masked, marker.end(), stop)
            if boundary:
                stop = boundary.start()
            spans.append((marker.start(), stop))
        return "rich_ordered_list" if rich else "top_level_ordered_list", spans
    
    
    def stage(source: Path, workspace: Path, *, render_html: bool = False) -> dict:
        raw = source.read_text(encoding="utf-8-sig")
        masked = markdown_mask(raw)
        _step_format, spans = operation_spans(raw)
        if not spans:
            raise ValueError(
                "Markdown needs numbered operation headings or top-level ordered operation lists; "
                "legacy-rich lists under '## 分段图文教程' are supported."
            )
        if any(
            (workspace / name).exists()
            for name in (
                "tutorial.md",
                "tutorial_path_refs.md",
                "steps_verified.json",
                "tutorial_manifest.json",
                "provided_images",
            )
        ):
            raise ValueError(
                "Provided tutorial outputs already exist; use a new empty workspace"
            )
        if re.search(r"<img\b", masked, re.I):
            raise ValueError(
                "HTML image tags are not supported; use Markdown local/base64 images"
            )
        image_dir = workspace / "provided_images"
        records = []
    
        def copy_image(alt: str, raw_target: str, title: str = "") -> str:
            target = re.sub(
                r"\\([\\`*_{}\[\]()#+.!<> '\"])", r"\1", raw_target.strip().strip("<>")
            )
            if target.startswith("data:image/"):
                header, encoded = target.split(",", 1)
                if ";base64" not in header:
                    raise ValueError("Only base64 data images are supported")
                content = base64.b64decode(encoded, validate=True)
                from PIL import Image
                import io
    
                picture = Image.open(io.BytesIO(content))
                suffix = {
                    "PNG": ".png",
                    "JPEG": ".jpg",
                    "WEBP": ".webp",
                    "GIF": ".gif",
                    "TIFF": ".tif",
                    "BMP": ".bmp",
                }.get(picture.format)
                if suffix is None:
                    raise ValueError("Unsupported embedded image format")
                picture.verify()
            else:
                if "://" in target:
                    raise ValueError(
                        "Download/authorize tutorial images yourself; Markdown images must be local or base64."
                    )
                path = (source.parent / unquote(target)).resolve(strict=True)
                if not path.is_relative_to(source.parent.resolve()) or not path.is_file():
                    raise ValueError(
                        "Tutorial image must be inside the tutorial's directory"
                    )
                content = path.read_bytes()
                from PIL import Image
                import io
    
                Image.open(io.BytesIO(content)).verify()
                suffix = path.suffix.lower()
            image_dir.mkdir(exist_ok=True)
            name = hashlib.sha256(content).hexdigest() + suffix
            dest = image_dir / name
            dest.write_bytes(content)
            relative = dest.relative_to(workspace).as_posix()
            records.append({"path": relative, "sha256": sha(dest)})
            return f"![{alt}]({relative}{' ' + title if title else ''})"
    
        definitions = {
            reference_key(m[1]): (m[2], m[3] or "") for m in DEFINITION.finditer(masked)
        }
        replacements = []
        covered = []
        for match in IMAGE.finditer(masked):
            replacements.append(
                (match.start(), match.end(), copy_image(match[1], match[2], match[3] or ""))
            )
            covered.append((match.start(), match.end()))
        for match in REFERENCE.finditer(masked):
            if any(start <= match.start() < end for start, end in covered):
                continue
            key = reference_key(match[2] or match[1])
            if match.end() < len(masked) and masked[match.end()] == "(":
                raise ValueError(
                    "Unsupported Markdown image destination; use <path with spaces> and an optional quoted title"
                )
            if key not in definitions:
                raise ValueError(
                    "Unresolved Markdown image reference: " + (match[2] or match[1])
                )
            target, title = definitions[key]
            replacements.append(
                (match.start(), match.end(), copy_image(match[1], target, title))
            )
        text = raw
        for start, end, replacement in sorted(replacements, reverse=True):
            text = text[:start] + replacement + text[end:]
        step_format, spans = operation_spans(text)
        steps = []
        for i, (start, end) in enumerate(spans):
            action = text[start:end].strip()
            step = {
                "step_id": f"S{i + 1:03d}",
                "action": action,
                "object": "",
                "parameters": {},
                "source": "user_provided_tutorial",
                "verification_status": "user_supplied_not_independently_video_verified",
            }
            # The rich merger prints the exact source interval in the list prefix.
            # Preserve that string only when present; generic lists get no invented
            # video start/end times, parameters or verification claims.
            interval = re.match(
                r"^[0-9]{1,9}[.)][ \t]+`(\d{1,3}:\d{2}(?::\d{2})?(?:\.\d+)?"
                r"[ \t]*[-–—][ \t]*\d{1,3}:\d{2}(?::\d{2})?(?:\.\d+)?)`",
                action,
            )
            if interval:
                step["time_range"] = interval[1]
            steps.append(step)
        for name in ("tutorial.md", "tutorial_path_refs.md"):
            (workspace / name).write_text(text, encoding="utf-8")
        (workspace / "steps_verified.json").write_text(
            json.dumps(
                {
                    "schema": SCHEMA,
                    "authority": "user_provided_instructions",
                    "verification_note": "Compatibility filename; this adapter does not claim video verification.",
                    "steps": steps,
                },
                ensure_ascii=False,
                indent=2,
            ),
            encoding="utf-8",
        )
        manifest = {
            "schema": SCHEMA,
            "tutorial_method": "provided",
            "source_sha256": sha(source),
            "step_format": step_format,
            "counts": {"steps": len(steps)},
            "images": records,
            "files": [
                {"path": n, "sha256": sha(workspace / n)}
                for n in ("tutorial.md", "tutorial_path_refs.md", "steps_verified.json")
            ],
        }
        (workspace / "tutorial_manifest.json").write_text(
            json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8"
        )
        if render_html:
            import markdown
    
            body = markdown.markdown(text, extensions=["tables", "fenced_code"])
            (workspace / "illustrated_tutorial.html").write_text(
                "<!doctype html><meta charset=\"utf-8\"><meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'\">"
                "<style>body{max-width:960px;margin:40px auto;font:17px/1.7 system-ui;padding:24px}img{max-width:100%}pre{overflow:auto}</style>"
                + body,
                encoding="utf-8",
            )
        return manifest
    
    
    def validate_workspace(workspace: Path) -> list[str]:
        try:
            manifest = json.loads((workspace / "tutorial_manifest.json").read_text())
            issues = []
            for item in [*manifest["files"], *manifest["images"]]:
                path = (workspace / item["path"]).resolve()
                if (
                    not path.is_relative_to(workspace.resolve())
                    or not path.is_file()
                    or sha(path) != item["sha256"]
                ):
                    issues.append("Missing or changed source item: " + item["path"])
            if manifest["counts"]["steps"] < 1:
                issues.append("No ordered instructions")
            return issues
        except (ValueError, OSError, KeyError) as exc:
            return ["Invalid provided tutorial: " + str(exc)]
    
  • skills/blender-pipeline/scripts/validate_package.py23 KBba87181968dbupstream ↗
    #!/usr/bin/env python3
    """Validate the standalone blender-pipeline skill without external packages."""
    
    from __future__ import annotations
    
    import argparse
    import ast
    import json
    import re
    import sys
    from dataclasses import asdict, dataclass
    from datetime import date
    from pathlib import Path
    from typing import Any, Callable, Iterable, Mapping, Sequence
    from urllib.parse import unquote, urlsplit
    
    
    DEFAULT_ROOT = Path(__file__).resolve().parents[1]
    TEXT_SUFFIXES = {
        ".csv",
        ".html",
        ".json",
        ".md",
        ".py",
        ".sh",
        ".toml",
        ".txt",
        ".yaml",
        ".yml",
    }
    IGNORED_DIRS = {
        ".git",
        ".mypy_cache",
        ".pytest_cache",
        ".ruff_cache",
        ".venv",
        "__pycache__",
        "__MACOSX",
    }
    FORBIDDEN_ARTIFACT_SUFFIXES = {
        ".7z",
        ".avi",
        ".blend",
        ".blend1",
        ".bz2",
        ".db",
        ".fbx",
        ".gif",
        ".glb",
        ".gltf",
        ".gz",
        ".jpeg",
        ".jpg",
        ".log",
        ".m4v",
        ".mkv",
        ".mov",
        ".mp4",
        ".obj",
        ".png",
        ".rar",
        ".sqlite",
        ".stl",
        ".tar",
        ".tgz",
        ".usda",
        ".usdc",
        ".usd",
        ".webm",
        ".webp",
        ".xz",
        ".zip",
    }
    REQUIRED_FILES = {
        Path("SKILL.md"),
        Path("agents/openai.yaml"),
        Path("references/codex-launch.md"),
        Path("scripts/launch_from_codex.py"),
        Path("generation/SKILL.md"),
        Path("generation/requirements.txt"),
        Path("generation/requirements-knowledge.txt"),
        Path("editing/SKILL.md"),
        Path("editing/pyproject.toml"),
        Path("editing/schemas/assessment.schema.json"),
        Path("editing/schemas/edit_request.schema.json"),
        Path("editing/schemas/review_package.schema.json"),
        Path("editing/schemas/source_map.schema.json"),
        Path("editing/schemas/edit_receipt.schema.json"),
        Path("generation/scripts/render_illustrated_tutorial.py"),
        Path("generation/scripts/codex_cli_chat_bridge.py"),
        Path("generation/scripts/camera_framing.py"),
        Path("tutorial-extraction/SKILL.md"),
        Path("tutorial-extraction/agents/openai.yaml"),
        Path("tutorial-extraction/requirements.txt"),
        Path("tutorial-extraction/references/output-contract.md"),
        Path("tutorial-extraction/references/profiles-and-evidence.md"),
        Path("tutorial-extraction/schemas/manifest.schema.json"),
        Path("tutorial-extraction/schemas/steps.schema.json"),
        Path("tutorial-extraction/scripts/extract_video_tutorial.py"),
        Path("tutorial-extraction/scripts/visual_tutorial_pipeline.py"),
        Path("tutorial-extraction/scripts/legacy_rich_tutorial_pipeline.py"),
        Path("tutorial-extraction/scripts/prepare_video.py"),
        Path("tutorial-extraction/scripts/validate_visual_package.py"),
        Path("tutorial-extraction/references/evidence-ledger.md"),
        Path("tutorial-extraction/references/markdown-layout.md"),
        Path("tutorial-extraction/references/blender-capability-rubric.md"),
        Path("tutorial-extraction/scripts/tutorial_extraction_core.py"),
        Path("tutorial-extraction/scripts/validate_tutorial_package.py"),
        Path("tutorial-extraction/tests/test_visual_tutorial_pipeline.py"),
        Path("knowledge/index.md"),
        Path("knowledge/manifest.json"),
        Path("knowledge/manifest.schema.json"),
        Path("knowledge/evidence-and-routing.md"),
        Path("knowledge/generation.md"),
        Path("knowledge/editing.md"),
        Path("knowledge/rendering-and-dynamics.md"),
        Path("knowledge/operations-and-knowledge.md"),
        Path("scripts/validate_package.py"),
        Path("scripts/pipeline_launcher.py"),
        Path("scripts/provided_tutorial.py"),
        Path("scripts/inspect_input_asset.py"),
        Path("reproduction/SKILL.md"),
        Path("reproduction/references/execution-contract.md"),
        Path("reproduction/scripts/export_public_showcase_knowledge.py"),
        Path("reproduction/scripts/launch_video2blender_reproduction.py"),
        Path("reproduction/scripts/reproduce.sh"),
        Path("reproduction/scripts/validate_public_knowledge.py"),
        Path("reproduction/knowledge/manifest.json"),
        Path("reproduction/knowledge/public_media_attestations.json"),
        Path("reproduction/knowledge/public_showcase_inventory.json"),
    }
    REQUIRED_DIRS = {
        Path("generation/scripts"),
        Path("generation/tests"),
        Path("editing/src/blender_edit_pipeline"),
        Path("editing/tests"),
        Path("reproduction/tests"),
        Path("tutorial-extraction/tests"),
        Path("tests"),
    }
    LOCAL_IMPORT_PREFIXES = (
        "agent_",
        "blender_",
        "build_",
        "embed_",
        "extract_",
        "generate_",
        "merge_",
        "model_direct_",
        "prepare_",
        "project_paths",
        "render_",
        "retrieve_",
        "run_video_",
        "rw1_",
        "scan_",
        "update_",
        "video_replay_",
    )
    MARKDOWN_LINK = re.compile(r"!?\[[^\]]*\]\(([^)]+)\)")
    
    
    @dataclass(frozen=True, order=True)
    class Issue:
        check: str
        path: str
        message: str
    
    
    def relative(path: Path, root: Path) -> str:
        try:
            return path.relative_to(root).as_posix()
        except ValueError:
            return path.as_posix()
    
    
    def iter_files(root: Path, suffixes: set[str] | None = None) -> Iterable[Path]:
        for path in sorted(root.rglob("*")):
            if any(part in IGNORED_DIRS or part.startswith("._") for part in path.parts):
                continue
            if not path.is_file():
                continue
            if suffixes is not None and path.suffix.lower() not in suffixes:
                continue
            yield path
    
    
    def read_text(path: Path) -> str:
        return path.read_text(encoding="utf-8")
    
    
    def frontmatter(text: str) -> dict[str, str]:
        lines = text.splitlines()
        if len(lines) < 4 or lines[0].strip() != "---":
            return {}
        result: dict[str, str] = {}
        for line in lines[1:]:
            if line.strip() == "---":
                return result
            if ":" in line:
                key, value = line.split(":", 1)
                result[key.strip()] = value.strip().strip("\"'")
        return {}
    
    
    def check_completeness(root: Path) -> list[Issue]:
        issues: list[Issue] = []
        for item in sorted(REQUIRED_FILES):
            if not (root / item).is_file():
                issues.append(
                    Issue("completeness", item.as_posix(), "required file is missing")
                )
        for item in sorted(REQUIRED_DIRS):
            path = root / item
            if not path.is_dir() or not any(
                candidate.is_file() for candidate in path.rglob("*")
            ):
                issues.append(
                    Issue(
                        "completeness",
                        item.as_posix(),
                        "required directory is empty or missing",
                    )
                )
    
        for skill_path in (
            root / "SKILL.md",
            root / "generation/SKILL.md",
            root / "editing/SKILL.md",
            root / "reproduction/SKILL.md",
            root / "tutorial-extraction/SKILL.md",
        ):
            if not skill_path.is_file():
                continue
            metadata = frontmatter(read_text(skill_path))
            for key in ("name", "description"):
                if not metadata.get(key):
                    issues.append(
                        Issue(
                            "completeness",
                            relative(skill_path, root),
                            f"frontmatter lacks {key}",
                        )
                    )
    
        top_skill = root / "SKILL.md"
        if top_skill.is_file():
            top_text = read_text(top_skill)
            if len(top_text.splitlines()) > 80:
                issues.append(
                    Issue(
                        "completeness",
                        "SKILL.md",
                        "router exceeds the 80-line disclosure budget",
                    )
                )
            if frontmatter(top_text).get("name") != root.name:
                issues.append(
                    Issue(
                        "completeness",
                        "SKILL.md",
                        "skill name must match the package directory",
                    )
                )
    
        for path in iter_files(root):
            rel = relative(path, root)
            lowered = path.name.lower()
            if path.is_symlink():
                issues.append(
                    Issue(
                        "completeness",
                        rel,
                        "symbolic links are not allowed in the standalone package",
                    )
                )
            if lowered in {"readme.md", "changelog.md", "changes.md"}:
                issues.append(
                    Issue(
                        "completeness",
                        rel,
                        "auxiliary documentation is outside the package contract",
                    )
                )
            if path.suffix.lower() in FORBIDDEN_ARTIFACT_SUFFIXES:
                issues.append(
                    Issue(
                        "completeness",
                        rel,
                        "generated or binary artifact is not package source",
                    )
                )
            if path.stat().st_size > 2_000_000:
                issues.append(
                    Issue("completeness", rel, "file exceeds the 2 MB source-package limit")
                )
        return issues
    
    
    def _sensitive_patterns() -> Sequence[tuple[str, re.Pattern[str]]]:
        return (
            (
                "personal home path",
                re.compile(r"(?<![A-Za-z0-9_])/(?:Users|home)/[^/\s]+/"),
            ),
            ("mounted-volume path", re.compile(r"(?<![A-Za-z0-9_])/Volumes/")),
            ("internal share path", re.compile(r"(?<![A-Za-z0-9_])/F[0-9]{8,}/")),
            ("Windows user path", re.compile(r"[A-Za-z]:\\\\Users\\\\[^\\\s]+\\\\")),
            ("GitHub token", re.compile(r"gh[pousr]_[A-Za-z0-9]{20,}")),
            ("API secret", re.compile(r"sk-[A-Za-z0-9_-]{20,}")),
            ("cloud access key", re.compile(r"AKIA[0-9A-Z]{16}")),
            (
                "private key",
                re.compile(r"-----BEGIN (?:OPENSSH|RSA|EC|DSA) PRIVATE KEY-----"),
            ),
            ("private WeChat path", re.compile(r"xwechat_files", re.IGNORECASE)),
            ("embedded file URL", re.compile(r"file://", re.IGNORECASE)),
            ("embedded data URI", re.compile(r"data:(?:image|video)/", re.IGNORECASE)),
            ("credential in URL", re.compile(r"https?://[^/\s:@]+:[^/\s@]+@")),
        )
    
    
    def check_sensitive_paths(root: Path) -> list[Issue]:
        issues: list[Issue] = []
        validator = (root / "scripts/validate_package.py").resolve()
        for path in iter_files(root, TEXT_SUFFIXES):
            if path.resolve() == validator:
                continue
            try:
                text = read_text(path)
            except UnicodeDecodeError:
                issues.append(
                    Issue(
                        "sensitive", relative(path, root), "declared text file is not UTF-8"
                    )
                )
                continue
            for label, pattern in _sensitive_patterns():
                if label == "embedded data URI" and path.suffix.lower() in {".py", ".sh"}:
                    continue
                for match in pattern.finditer(text):
                    line = text.count("\n", 0, match.start()) + 1
                    issues.append(
                        Issue("sensitive", f"{relative(path, root)}:{line}", label)
                    )
        return issues
    
    
    def _module_exists(base: Path, parts: Sequence[str]) -> bool:
        if not parts:
            return True
        target = base.joinpath(*parts)
        return target.with_suffix(".py").is_file() or (target / "__init__.py").is_file()
    
    
    def _import_names(node: ast.AST) -> Iterable[tuple[str, int]]:
        if isinstance(node, ast.Import):
            for alias in node.names:
                yield alias.name, 0
        elif isinstance(node, ast.ImportFrom):
            yield node.module or "", node.level
    
    
    def _check_relative_import(path: Path, module: str, level: int) -> bool:
        base = path.parent
        for _ in range(max(0, level - 1)):
            base = base.parent
        return _module_exists(base, module.split(".") if module else ())
    
    
    def check_imports(root: Path) -> list[Issue]:
        issues: list[Issue] = []
        generation_scripts = root / "generation/scripts"
        generation_modules = {
            path.stem
            for path in generation_scripts.glob("*.py")
            if path.name != "__init__.py"
        }
        editing_src = root / "editing/src"
    
        for path in iter_files(root, {".py"}):
            rel = relative(path, root)
            try:
                tree = ast.parse(read_text(path), filename=rel)
            except (SyntaxError, UnicodeDecodeError) as exc:
                issues.append(Issue("imports", rel, f"Python source does not parse: {exc}"))
                continue
    
            for node in ast.walk(tree):
                for module, level in _import_names(node):
                    if level:
                        if not _check_relative_import(path, module, level):
                            issues.append(
                                Issue(
                                    "imports",
                                    f"{rel}:{getattr(node, 'lineno', 0)}",
                                    f"unresolved relative import {'.' * level}{module}",
                                )
                            )
                        continue
    
                    parts = module.split(".") if module else []
                    top = parts[0] if parts else ""
                    if top == "blender_edit_pipeline":
                        if not _module_exists(editing_src, parts):
                            issues.append(
                                Issue(
                                    "imports",
                                    f"{rel}:{getattr(node, 'lineno', 0)}",
                                    f"unresolved editing import {module}",
                                )
                            )
                        continue
    
                    in_generation = (
                        generation_scripts in path.parents
                        or root / "generation/tests" in path.parents
                    )
                    looks_local = top in generation_modules or top.startswith(
                        LOCAL_IMPORT_PREFIXES
                    )
                    if (
                        in_generation
                        and looks_local
                        and not _module_exists(generation_scripts, parts)
                    ):
                        issues.append(
                            Issue(
                                "imports",
                                f"{rel}:{getattr(node, 'lineno', 0)}",
                                f"unresolved generation import {module}",
                            )
                        )
        return issues
    
    
    def _json_type_matches(value: Any, expected: str) -> bool:
        mapping: Mapping[str, type | tuple[type, ...]] = {
            "array": list,
            "boolean": bool,
            "integer": int,
            "null": type(None),
            "number": (int, float),
            "object": dict,
            "string": str,
        }
        target = mapping.get(expected)
        if target is None:
            return False
        if expected in {"integer", "number"} and isinstance(value, bool):
            return False
        return isinstance(value, target)
    
    
    def _validate_schema(
        value: Any, schema: Mapping[str, Any], location: str = "$"
    ) -> list[str]:
        errors: list[str] = []
        if "const" in schema and value != schema["const"]:
            errors.append(f"{location}: expected constant {schema['const']!r}")
        if "enum" in schema and value not in schema["enum"]:
            errors.append(f"{location}: value is outside the declared enum")
        expected_type = schema.get("type")
        if expected_type and not _json_type_matches(value, expected_type):
            errors.append(f"{location}: expected {expected_type}")
            return errors
    
        if isinstance(value, dict):
            required = schema.get("required", [])
            for key in required:
                if key not in value:
                    errors.append(f"{location}: missing required property {key!r}")
            properties = schema.get("properties", {})
            if schema.get("additionalProperties") is False:
                for key in value:
                    if key not in properties:
                        errors.append(f"{location}: undeclared property {key!r}")
            for key, child_schema in properties.items():
                if key in value:
                    errors.extend(
                        _validate_schema(value[key], child_schema, f"{location}.{key}")
                    )
    
        if isinstance(value, list):
            minimum = schema.get("minItems")
            if minimum is not None and len(value) < minimum:
                errors.append(f"{location}: requires at least {minimum} items")
            if schema.get("uniqueItems"):
                canonical = [
                    json.dumps(item, ensure_ascii=False, sort_keys=True) for item in value
                ]
                if len(canonical) != len(set(canonical)):
                    errors.append(f"{location}: items must be unique")
            item_schema = schema.get("items")
            if isinstance(item_schema, dict):
                for index, item in enumerate(value):
                    errors.extend(
                        _validate_schema(item, item_schema, f"{location}[{index}]")
                    )
    
        if isinstance(value, str):
            minimum = schema.get("minLength")
            if minimum is not None and len(value) < minimum:
                errors.append(f"{location}: requires at least {minimum} characters")
            pattern = schema.get("pattern")
            if pattern and re.search(pattern, value) is None:
                errors.append(f"{location}: does not match {pattern!r}")
            if schema.get("format") == "date":
                try:
                    date.fromisoformat(value)
                except ValueError:
                    errors.append(f"{location}: invalid ISO date")
        return errors
    
    
    def check_json_schemas(root: Path) -> list[Issue]:
        issues: list[Issue] = []
        parsed: dict[Path, Any] = {}
        for path in iter_files(root, {".json"}):
            try:
                parsed[path] = json.loads(read_text(path))
            except (json.JSONDecodeError, UnicodeDecodeError) as exc:
                issues.append(
                    Issue("json-schema", relative(path, root), f"invalid JSON: {exc}")
                )
    
        schema_path = root / "knowledge/manifest.schema.json"
        manifest_path = root / "knowledge/manifest.json"
        if schema_path not in parsed or manifest_path not in parsed:
            return issues
        schema = parsed[schema_path]
        manifest = parsed[manifest_path]
        if (
            not isinstance(schema, dict)
            or schema.get("$schema") != "https://json-schema.org/draft/2020-12/schema"
        ):
            issues.append(
                Issue(
                    "json-schema",
                    "knowledge/manifest.schema.json",
                    "unsupported or missing schema dialect",
                )
            )
            return issues
        if not isinstance(manifest, dict):
            issues.append(
                Issue(
                    "json-schema", "knowledge/manifest.json", "manifest must be an object"
                )
            )
            return issues
        for error in _validate_schema(manifest, schema):
            issues.append(Issue("json-schema", "knowledge/manifest.json", error))
    
        window = manifest.get("recent_extraction_window", {})
        if isinstance(window, dict):
            start = window.get("from")
            through = window.get("through")
            try:
                if date.fromisoformat(str(start)) > date.fromisoformat(str(through)):
                    issues.append(
                        Issue(
                            "json-schema",
                            "knowledge/manifest.json",
                            "knowledge window is reversed",
                        )
                    )
            except ValueError:
                pass
            if through != manifest.get("updated_through"):
                issues.append(
                    Issue(
                        "json-schema",
                        "knowledge/manifest.json",
                        "updated_through differs from window through",
                    )
                )
    
        declared_paths = [
            item.get("path")
            for item in manifest.get("documents", [])
            if isinstance(item, dict) and isinstance(item.get("path"), str)
        ]
        if len(declared_paths) != len(set(declared_paths)):
            issues.append(
                Issue(
                    "json-schema",
                    "knowledge/manifest.json",
                    "document paths must be unique",
                )
            )
        declared = set(declared_paths)
        actual = {
            path.name
            for path in (root / "knowledge").glob("*.md")
            if not path.name.startswith("._")
        }
        if declared != actual:
            issues.append(
                Issue(
                    "json-schema",
                    "knowledge/manifest.json",
                    f"declared Markdown differs from knowledge directory: declared={sorted(declared)}, actual={sorted(actual)}",
                )
            )
        return issues
    
    
    def _markdown_target(raw: str) -> str:
        value = raw.strip()
        if value.startswith("<") and ">" in value:
            return value[1 : value.index(">")]
        return value.split(maxsplit=1)[0]
    
    
    def check_links(root: Path) -> list[Issue]:
        issues: list[Issue] = []
        root_resolved = root.resolve()
        for path in iter_files(root, {".md"}):
            text = read_text(path)
            for match in MARKDOWN_LINK.finditer(text):
                target = unquote(_markdown_target(match.group(1)))
                parsed = urlsplit(target)
                if parsed.scheme or target.startswith("//"):
                    continue
                local_part = parsed.path
                if not local_part:
                    continue
                candidate = (path.parent / local_part).resolve()
                line = text.count("\n", 0, match.start()) + 1
                rel = f"{relative(path, root)}:{line}"
                if not candidate.is_relative_to(root_resolved):
                    issues.append(
                        Issue("links", rel, f"local link escapes package root: {target}")
                    )
                elif not candidate.exists():
                    issues.append(Issue("links", rel, f"broken local link: {target}"))
        return issues
    
    
    CHECKS: Mapping[str, Callable[[Path], list[Issue]]] = {
        "completeness": check_completeness,
        "sensitive": check_sensitive_paths,
        "imports": check_imports,
        "json-schema": check_json_schemas,
        "links": check_links,
    }
    
    
    def validate(root: Path, names: Sequence[str] | None = None) -> list[Issue]:
        selected = tuple(names or CHECKS)
        issues: list[Issue] = []
        for name in selected:
            issues.extend(CHECKS[name](root))
        return sorted(set(issues))
    
    
    def build_parser() -> argparse.ArgumentParser:
        parser = argparse.ArgumentParser(description=__doc__)
        parser.add_argument(
            "--root", type=Path, default=DEFAULT_ROOT, help="blender-pipeline skill root"
        )
        parser.add_argument(
            "--check",
            action="append",
            choices=sorted(CHECKS),
            dest="checks",
            help="run only one named check; repeat as needed",
        )
        parser.add_argument(
            "--json", action="store_true", help="emit a machine-readable report"
        )
        return parser
    
    
    def main(argv: Sequence[str] | None = None) -> int:
        args = build_parser().parse_args(argv)
        root = args.root.resolve()
        issues = validate(root, args.checks)
        if args.json:
            print(
                json.dumps(
                    {
                        "root": str(root),
                        "status": "fail" if issues else "pass",
                        "issues": [asdict(issue) for issue in issues],
                    },
                    ensure_ascii=False,
                    indent=2,
                    sort_keys=True,
                )
            )
        elif issues:
            for issue in issues:
                print(f"{issue.check}: {issue.path}: {issue.message}", file=sys.stderr)
            print(f"FAIL: {len(issues)} package issue(s)", file=sys.stderr)
        else:
            selected = ", ".join(args.checks or CHECKS)
            print(f"PASS: blender-pipeline package ({selected})")
        return 1 if issues else 0
    
    
    if __name__ == "__main__":
        raise SystemExit(main())
    
  • skills/blender-pipeline/references/codex-launch.md7.3 KB5feeaaf59213upstream ↗
    # Codex conversation launcher
    
    ## Interpret the request
    
    The interaction is: select `$blender-pipeline`, then provide the video/tutorial
    and any supporting files in normal language. Codex constructs and runs the
    command. Do not ask the user to translate their request into CLI arguments.
    If the skill is selected without any task input, ask for the video URL/file or
    Markdown tutorial. Honor requests to explain or preview without execution.
    
    Resolve the intended output before starting downloads, model calls or Blender:
    
    | Input | Tutorial-only workflow | Reconstruction workflow |
    | --- | --- | --- |
    | Video URL or local video | Extract illustrated Markdown; optional HTML | Extract → retrieve knowledge → reconstruct → render |
    | Video with starter project / supporting files | Extract with the supplied learner inputs | Preserve the starter and use its dependencies during reconstruction |
    | Markdown tutorial, optionally with assets | Prepare existing Markdown/images; optional HTML, no video extraction | Skip extraction → retrieve knowledge → reconstruct → render |
    
    If a video is supplied without an explicit goal, ask: “你希望只生成图文教程,还是继续复现视频中的 Blender 作品?”
    For Markdown, ask: “你希望整理这份图文教程,还是按教程生成 Blender 作品?”
    Use the user's language. A clear request such as “只要教程”, “转 HTML”, or
    “复现并生成 .blend” already answers this question; do not ask again or treat
    the Skill's generic selection prompt as authorization for reconstruction.
    Wait for the answer; combine genuinely missing source/output questions when
    possible. Follow the user's latest choice, not a default inferred from input type.
    
    Accept multiple independent video links in one message. Run them sequentially,
    with one `--video-url` per helper invocation and a separate subject/BVID-named
    child directory under the selected output root. Ask about the goal once for
    the batch, not once per video; preserve any explicitly different per-video goals
    and supporting inputs. Do not pass a list or repeat `--video-url` in one call.
    If the user intends several videos to contribute to a single asset, clarify
    that separate runs do not merge tutorials instead of silently discarding links.
    
    Select one primary source and preserve each attachment's actual role:
    
    | Supplied input | Internal argument |
    | --- | --- |
    | Video link | `--video-url` |
    | Local video file | `--video-file` |
    | Existing Markdown tutorial | `--tutorial` |
    | Starting `.blend`, `.glb`, `.gltf`, `.obj`, or `.fbx` | `--asset` |
    | Complete dependency directory containing that model | `--asset-root` |
    | Texture or other learner resource | repeat `--input-asset` |
    | Starting-asset preview | repeat `--preview` |
    | Finished-result reference | `--target-image` |
    | Timestamped transcript | `--transcript` |
    
    A video plus a starter project stays within the selected workflow, not a separate edit.
    Markdown may also include a starter project or textures. Retain the tutorial's
    relative images and the model's dependency structure. Do not use a starting
    preview as a texture or final target. If an image's role or the primary source
    is genuinely ambiguous, ask one concise question before launching. A text-only
    Markdown replay needs a finished-result image; ask for it when absent. Do not
    silently convert a full replay into extraction-only to avoid missing input.
    
    ## Resolve the run location
    
    Use the output directory explicitly requested by the user. Otherwise select a
    new subject-named run directory beneath the user's established data root from
    the conversation or `BLENDER_PIPELINE_OUTPUT_ROOT`. Add a timestamp when needed
    to avoid overwriting an earlier run. If no data location is established, ask
    once where to save the result. Respect external-disk requirements; never
    silently fall back to the system disk if that location is unavailable.
    
    Resolve the current skill directory from this `SKILL.md` location, following
    symlinks, rather than assuming the shell's working directory is the repository.
    Resolve supplied relative file paths against the user's workspace before
    invoking the helper. Quote each path as one argument, including spaces and
    non-ASCII names. Do not write inputs or results into the installed skill/repo.
    
    ## Launch and finish
    
    1. After resolving the goal, briefly state the selected workflow, mapped inputs
       and output location, then execute without another confirmation round.
    2. Invoke `scripts/launch_from_codex.py` under the resolved skill directory with
       the selected source, output directory and supporting arguments. For example,
       the following are internal invocations performed by Codex, not instructions
       to hand back to the user:
    
       ```text
       python3 "<skill-dir>/scripts/launch_from_codex.py" --video-url "<url>" --extract-only --render-html --output-dir "<new-run-dir>"
       python3 "<skill-dir>/scripts/launch_from_codex.py" --video-url "<url>" --output-dir "<new-run-dir>"
       python3 "<skill-dir>/scripts/launch_from_codex.py" --video-file "<video>" --asset "<starter.blend>" --preview "<before.png>" --output-dir "<new-run-dir>"
       python3 "<skill-dir>/scripts/launch_from_codex.py" --tutorial "<tutorial.md>" --output-dir "<new-run-dir>"
       ```
    
       Prefer the repository's `.venv/bin/python` (`.venv/Scripts/python.exe` on
       Windows) created during setup; otherwise use a compatible configured Python.
       The helper uses the signed-in Codex CLI for model calls. Do not ask for an
       API key or switch to API mode. Forward a user-supplied Blender executable as `--blender`.
       Missing Blender, FFmpeg, Python dependencies, or Codex login should be
       reported specifically; do not install large packages or launch a different
       workflow without user direction. Retain `gpt-5.6-sol` and the existing bounded
       call/repair settings; use `gpt-5.5` only through the supported explicit fallback.
    3. Map tutorial-only to `--extract-only`, and reconstruction to no such flag.
       `--check` and `--dry-run` are only for an explicit request for those operations.
       Use `visual` extraction by default (recommended for videos up to ten minutes);
       an explicit original rich/base64 request maps to `--tutorial-method legacy-rich`.
       Add `--render-html` only when requested. For an explicit rendering choice,
       set `VIDEO2BLENDER_CYCLES_BACKEND` for this invocation: `CPU`, `METAL` (Apple),
       `OPTIX`/`CUDA` (NVIDIA), `HIP` (AMD), or `ONEAPI` (Intel), as supported locally.
       Otherwise preserve the configured backend (default CPU); do not guess a GPU.
    4. Let the helper manage extraction, knowledge lookup, scene generation and
       review. Do not run those stages a second time manually. Follow a running
       process until it finishes or needs input; do not return only its process ID.
       Do not automatically restart an entire paid run after an unclear failure.
    5. For tutorial-only, read the exit status and link the produced `tutorial.md`,
       its local images, and requested HTML. Do not require `pipeline_review.json`
       or claim a Blender result. For reconstruction, read the exit status and
       `pipeline_review.json`; link the `.blend`, render, tutorial and any animation.
       Report a stopped stage or a result needing review as such, not full completion.
    
    API use remains available separately through the unchanged API launcher. Do not
    commit, push, publish results, or promote knowledge as a side effect of a Skill
    launch unless the user separately requests it.
    
  • skills/blender-pipeline/agents/openai.yaml300 B263f90302676upstream ↗
    interface:
      display_name: "Blender Pipeline"
      short_description: "Create a tutorial or reconstruct a Blender result from video"
      default_prompt: "使用 $blender-pipeline 处理我提供的视频、配套资产或 Markdown 图文教程;如果我没有说明需要哪种结果,请先询问。"
    
  • skills/blender-pipeline/editing/pyproject.toml576 B1b6c697c0bfbupstream ↗
    [build-system]
    requires = ["setuptools>=68"]
    build-backend = "setuptools.build_meta"
    
    [project]
    name = "blender-edit-pipeline"
    version = "0.1.0"
    description = "Contract-driven, scope-preserving edits of existing Blender projects"
    readme = {file = "SKILL.md", content-type = "text/markdown"}
    requires-python = ">=3.10"
    dependencies = []
    
    [project.optional-dependencies]
    test = ["jsonschema>=4.21,<5"]
    
    [project.scripts]
    blender-edit-pipeline = "blender_edit_pipeline.pipeline:main"
    
    [tool.setuptools]
    package-dir = {"" = "src"}
    
    [tool.setuptools.packages.find]
    where = ["src"]
    
  • skills/blender-pipeline/editing/schemas/assessment.schema.json1.5 KB8f1f3a17f14dupstream ↗
    {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "$id": "https://freedomintelligence.github.io/3D-Coding-Blender/schemas/blender-edit-assessment-v1.json",
      "title": "External Blender edit visual assessment",
      "type": "object",
      "additionalProperties": false,
      "required": ["schema", "decision", "review_package_sha256", "bindings", "assessor", "scores", "summary"],
      "properties": {
        "schema": {"const": "blender-edit-assessment/v1"},
        "decision": {"const": "accepted"},
        "review_package_sha256": {"$ref": "#/$defs/digest"},
        "bindings": {
          "type": "object", "additionalProperties": false,
          "required": ["candidate_sha256", "before_sha256", "after_sha256"],
          "properties": {
            "candidate_sha256": {"$ref": "#/$defs/digest"},
            "before_sha256": {"$ref": "#/$defs/digest"},
            "after_sha256": {"$ref": "#/$defs/digest"}
          }
        },
        "assessor": {
          "type": "object", "additionalProperties": false, "required": ["kind", "name"],
          "properties": {
            "kind": {"enum": ["human", "vlm"]},
            "name": {"type": "string", "minLength": 1, "maxLength": 256}
          }
        },
        "scores": {
          "type": "object", "additionalProperties": false, "required": ["before", "after"],
          "properties": {
            "before": {"type": "number", "minimum": 0, "maximum": 100},
            "after": {"type": "number", "minimum": 0, "maximum": 100}
          }
        },
        "summary": {"type": "string", "minLength": 1, "maxLength": 2000}
      },
      "$defs": {"digest": {"type": "string", "pattern": "^[0-9a-f]{64}$"}}
    }
    
  • skills/blender-pipeline/editing/schemas/edit_receipt.schema.json3.5 KB835919a19cf9upstream ↗
    {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "$id": "https://freedomintelligence.github.io/3D-Coding-Blender/schemas/blender-edit-receipt-v1.json",
      "title": "Completed Blender edit receipt",
      "type": "object",
      "additionalProperties": false,
      "required": ["schema", "status", "edit_id", "kind", "source", "request_sha256", "targets", "changes", "non_target_drift", "reopen", "review", "visual_evidence", "artifacts"],
      "properties": {
        "schema": {"const": "blender-edit-receipt/v1"}, "status": {"const": "complete"},
        "edit_id": {"type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$"},
        "kind": {"enum": ["material", "color", "geometry", "modeling", "scene"]},
        "source": {
          "type": "object", "additionalProperties": false, "required": ["filename", "sha256"],
          "properties": {"filename": {"type": "string"}, "sha256": {"$ref": "#/$defs/digest"}}
        },
        "request_sha256": {"$ref": "#/$defs/digest"},
        "targets": {"type": "object"}, "changes": {"type": "object"},
        "non_target_drift": {"type": "array", "maxItems": 0},
        "reopen": {
          "type": "object", "additionalProperties": false, "required": ["verified", "snapshot_digest"],
          "properties": {"verified": {"const": true}, "snapshot_digest": {"$ref": "#/$defs/digest"}}
        },
        "review": {
          "type": "object", "additionalProperties": false,
          "required": ["package_sha256", "assessment_sha256"],
          "properties": {
            "package_sha256": {"$ref": "#/$defs/digest"},
            "assessment_sha256": {"$ref": "#/$defs/digest"}
          }
        },
        "visual_evidence": {
          "type": "object", "additionalProperties": false,
          "required": ["before", "after", "difference", "assessment"],
          "properties": {
            "before": {"$ref": "#/$defs/artifact"},
            "after": {"$ref": "#/$defs/artifact"},
            "difference": {"$ref": "#/$defs/difference"},
            "assessment": {
              "type": "object", "additionalProperties": false,
              "required": ["kind", "name", "before_score", "after_score", "minimum_after_score", "summary", "sha256"],
              "properties": {
                "kind": {"enum": ["human", "vlm"]}, "name": {"type": "string", "minLength": 1},
                "before_score": {"type": "number", "minimum": 0, "maximum": 100},
                "after_score": {"type": "number", "minimum": 80, "maximum": 100},
                "minimum_after_score": {"type": "number", "minimum": 80, "maximum": 100},
                "summary": {"type": "string", "minLength": 1, "maxLength": 2000},
                "sha256": {"$ref": "#/$defs/digest"}
              }
            }
          }
        },
        "artifacts": {"type": "array", "minItems": 6, "maxItems": 6, "items": {"$ref": "#/$defs/artifact"}}
      },
      "$defs": {
        "digest": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
        "artifact": {
          "type": "object", "additionalProperties": false, "required": ["path", "sha256", "bytes"],
          "properties": {
            "path": {"enum": ["asset.blend", "before.png", "after.png", "source_map.json", "review_package.json", "assessment.json"]}, "sha256": {"$ref": "#/$defs/digest"},
            "bytes": {"type": "integer", "minimum": 1}
          }
        },
        "difference": {
          "type": "object", "additionalProperties": false,
          "required": ["width", "height", "changed_fraction", "mean_absolute_delta"],
          "properties": {
            "width": {"type": "integer", "minimum": 1}, "height": {"type": "integer", "minimum": 1},
            "changed_fraction": {"type": "number", "minimum": 0, "maximum": 1},
            "mean_absolute_delta": {"type": "number", "minimum": 0, "maximum": 255}
          }
        }
      }
    }
    
  • skills/blender-pipeline/editing/schemas/edit_request.schema.json11 KBfb8632ec1eb7upstream ↗
    {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "$id": "https://freedomintelligence.github.io/3D-Coding-Blender/schemas/blender-edit-request-v1.json",
      "title": "Blender edit request",
      "type": "object",
      "additionalProperties": false,
      "required": ["schema", "edit_id", "kind", "source_blend", "source_sha256", "targets", "parameters"],
      "properties": {
        "schema": {"const": "blender-edit-request/v1"},
        "edit_id": {"type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$"},
        "kind": {"enum": ["material", "color", "geometry", "modeling", "scene"]},
        "source_blend": {"type": "string", "minLength": 1},
        "source_sha256": {"$ref": "#/$defs/digest"},
        "targets": {"$ref": "#/$defs/targets"},
        "parameters": {"type": "object", "minProperties": 1},
        "evidence": {"$ref": "#/$defs/evidence"}
      },
      "allOf": [
        {
          "if": {"properties": {"kind": {"const": "material"}}},
          "then": {"properties": {
            "targets": {"required": ["materials"], "propertyNames": {"const": "materials"}},
            "parameters": {"$ref": "#/$defs/material_parameters"}
          }}
        },
        {
          "if": {"properties": {"kind": {"const": "color"}}},
          "then": {"properties": {
            "targets": {"required": ["materials"], "propertyNames": {"const": "materials"}},
            "parameters": {"$ref": "#/$defs/color_parameters"}
          }}
        },
        {
          "if": {"properties": {"kind": {"const": "geometry"}}},
          "then": {"properties": {
            "targets": {"required": ["objects"], "propertyNames": {"const": "objects"}},
            "parameters": {"$ref": "#/$defs/geometry_parameters"}
          }}
        },
        {
          "if": {"properties": {"kind": {"const": "modeling"}}},
          "then": {"properties": {
            "targets": {
              "propertyNames": {"enum": ["objects", "generated_objects"]},
              "anyOf": [{"required": ["objects"]}, {"required": ["generated_objects"]}]
            },
            "parameters": {"$ref": "#/$defs/modeling_parameters"}
          }}
        },
        {
          "if": {"properties": {"kind": {"const": "scene"}}},
          "then": {"properties": {
            "targets": {"propertyNames": {"enum": ["lights", "camera"]}},
            "parameters": {"$ref": "#/$defs/scene_parameters"}
          }}
        }
      ],
      "$defs": {
        "digest": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
        "number": {"type": "number"},
        "unit_number": {"type": "number", "minimum": 0, "maximum": 1},
        "vec2": {"type": "array", "items": {"$ref": "#/$defs/number"}, "minItems": 2, "maxItems": 2},
        "vec3": {"type": "array", "items": {"$ref": "#/$defs/number"}, "minItems": 3, "maxItems": 3},
        "color3": {"type": "array", "items": {"$ref": "#/$defs/unit_number"}, "minItems": 3, "maxItems": 3},
        "color": {"type": "array", "items": {"$ref": "#/$defs/unit_number"}, "minItems": 3, "maxItems": 4},
        "names": {"type": "array", "items": {"type": "string", "minLength": 1}, "minItems": 1, "uniqueItems": true},
        "targets": {
          "type": "object", "additionalProperties": false,
          "properties": {
            "objects": {"$ref": "#/$defs/names"}, "materials": {"$ref": "#/$defs/names"},
            "lights": {"$ref": "#/$defs/names"}, "camera": {"$ref": "#/$defs/names"},
            "generated_objects": {"$ref": "#/$defs/names"}
          }
        },
        "principled_inputs": {
          "type": "object", "additionalProperties": false, "minProperties": 1,
          "properties": {
            "Base Color": {"$ref": "#/$defs/color"}, "Emission Color": {"$ref": "#/$defs/color"},
            "Metallic": {"$ref": "#/$defs/unit_number"}, "Roughness": {"$ref": "#/$defs/unit_number"},
            "IOR": {"type": "number", "minimum": 1, "maximum": 4}, "Alpha": {"$ref": "#/$defs/unit_number"},
            "Transmission Weight": {"$ref": "#/$defs/unit_number"}, "Coat Weight": {"$ref": "#/$defs/unit_number"},
            "Coat Roughness": {"$ref": "#/$defs/unit_number"}
          }
        },
        "material_parameters": {
          "type": "object", "additionalProperties": false, "required": ["materials"],
          "properties": {"materials": {"type": "object", "minProperties": 1, "additionalProperties": {"$ref": "#/$defs/principled_inputs"}}}
        },
        "hue_adjustment": {
          "type": "object", "additionalProperties": false, "minProperties": 1,
          "properties": {
            "hue": {"type": "number", "minimum": 0, "maximum": 1},
            "saturation": {"type": "number", "minimum": 0, "maximum": 2},
            "value": {"type": "number", "minimum": 0, "maximum": 2},
            "factor": {"$ref": "#/$defs/unit_number"}
          }
        },
        "color_parameters": {
          "oneOf": [
            {
              "type": "object", "additionalProperties": false, "required": ["colors"],
              "properties": {"colors": {"type": "object", "minProperties": 1, "additionalProperties": {"$ref": "#/$defs/color"}}}
            },
            {
              "type": "object", "additionalProperties": false, "required": ["hue_saturation"],
              "properties": {"hue_saturation": {"type": "object", "minProperties": 1, "additionalProperties": {"$ref": "#/$defs/hue_adjustment"}}}
            }
          ]
        },
        "face": {"type": "array", "items": {"type": "integer", "minimum": 0}, "minItems": 3, "uniqueItems": true},
        "uv_layers": {
          "type": "object", "minProperties": 1,
          "additionalProperties": {"type": "array", "items": {"$ref": "#/$defs/vec2"}}
        },
        "geometry_inline_replacement": {
          "type": "object", "additionalProperties": false, "required": ["vertices", "faces"],
          "properties": {
            "vertices": {"type": "array", "items": {"$ref": "#/$defs/vec3"}, "minItems": 4},
            "faces": {"type": "array", "items": {"$ref": "#/$defs/face"}, "minItems": 1},
            "uv_layers": {"$ref": "#/$defs/uv_layers"}, "fit_to_source_bbox": {"type": "boolean"},
            "envelope_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
            "volume_ratio_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
            "world_center_tolerance": {"type": "number", "minimum": 0, "maximum": 100000}
          }
        },
        "geometry_generation_handoff": {
          "type": "object", "additionalProperties": false,
          "required": ["attempt_receipt", "attempt_receipt_sha256", "asset_blend", "asset_blend_sha256", "object"],
          "properties": {
            "attempt_receipt": {"type": "string", "minLength": 1},
            "attempt_receipt_sha256": {"$ref": "#/$defs/digest"},
            "asset_blend": {"type": "string", "minLength": 1},
            "asset_blend_sha256": {"$ref": "#/$defs/digest"},
            "object": {"type": "string", "minLength": 1},
            "fit_to_source_bbox": {"type": "boolean"},
            "envelope_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
            "volume_ratio_tolerance": {"type": "number", "minimum": 0, "maximum": 1},
            "world_center_tolerance": {"type": "number", "minimum": 0, "maximum": 100000}
          }
        },
        "geometry_parameters": {
          "type": "object", "additionalProperties": false, "required": ["replacements"],
          "properties": {
            "replacements": {
              "type": "object", "minProperties": 1,
              "additionalProperties": {
                "oneOf": [
                  {"$ref": "#/$defs/geometry_inline_replacement"},
                  {"$ref": "#/$defs/geometry_generation_handoff"}
                ]
              }
            }
          }
        },
        "add_primitive": {
          "type": "object", "additionalProperties": false, "required": ["op", "name", "primitive", "collection"],
          "properties": {
            "op": {"const": "add_primitive"}, "name": {"type": "string", "minLength": 1},
            "primitive": {"enum": ["cube", "uv_sphere", "cylinder", "cone", "torus"]},
            "collection": {"type": "string", "minLength": 1}, "location": {"$ref": "#/$defs/vec3"},
            "rotation": {"$ref": "#/$defs/vec3"}, "scale": {"$ref": "#/$defs/vec3"}
          }
        },
        "modifier_settings": {
          "type": "object", "additionalProperties": false,
          "properties": {
            "width": {"type": "number", "minimum": 0, "maximum": 100000},
            "segments": {"type": "integer", "minimum": 1, "maximum": 64},
            "thickness": {"type": "number", "minimum": -100000, "maximum": 100000},
            "offset": {"type": "number", "minimum": -1, "maximum": 1},
            "levels": {"type": "integer", "minimum": 0, "maximum": 6},
            "render_levels": {"type": "integer", "minimum": 0, "maximum": 6}
          }
        },
        "add_modifier": {
          "type": "object", "additionalProperties": false, "required": ["op", "object", "modifier_type"],
          "properties": {
            "op": {"const": "add_modifier"}, "object": {"type": "string", "minLength": 1},
            "modifier_type": {"enum": ["BEVEL", "SOLIDIFY", "SUBSURF"]},
            "name": {"type": "string", "minLength": 1}, "settings": {"$ref": "#/$defs/modifier_settings"}
          }
        },
        "modeling_parameters": {
          "type": "object", "additionalProperties": false, "required": ["operations"],
          "properties": {
            "operations": {"type": "array", "minItems": 1, "items": {"oneOf": [{"$ref": "#/$defs/add_primitive"}, {"$ref": "#/$defs/add_modifier"}]}}
          }
        },
        "light_edit": {
          "type": "object", "additionalProperties": false, "minProperties": 1,
          "properties": {
            "energy": {"type": "number", "minimum": 0, "maximum": 1000000},
            "energy_multiplier": {"type": "number", "minimum": 0, "maximum": 100},
            "color": {"$ref": "#/$defs/color3"}, "shadow_soft_size": {"type": "number", "minimum": 0, "maximum": 1000}
          },
          "not": {"required": ["energy", "energy_multiplier"]}
        },
        "camera_edit": {
          "type": "object", "additionalProperties": false, "minProperties": 1,
          "properties": {
            "location": {"$ref": "#/$defs/vec3"}, "rotation": {"$ref": "#/$defs/vec3"},
            "lens": {"type": "number", "minimum": 1, "maximum": 1000}
          }
        },
        "scene_parameters": {
          "type": "object", "additionalProperties": false, "minProperties": 1,
          "properties": {
            "lights": {"type": "object", "additionalProperties": {"$ref": "#/$defs/light_edit"}},
            "cameras": {"type": "object", "additionalProperties": {"$ref": "#/$defs/camera_edit"}},
            "allow_world": {"type": "boolean"}, "world_color": {"$ref": "#/$defs/color3"},
            "allow_exposure": {"type": "boolean"}, "exposure": {"type": "number", "minimum": -32, "maximum": 32}
          },
          "allOf": [
            {"if": {"required": ["allow_world"], "properties": {"allow_world": {"const": true}}}, "then": {"required": ["world_color"]}},
            {"if": {"required": ["world_color"]}, "then": {"required": ["allow_world"], "properties": {"allow_world": {"const": true}}}},
            {"if": {"required": ["allow_exposure"], "properties": {"allow_exposure": {"const": true}}}, "then": {"required": ["exposure"]}},
            {"if": {"required": ["exposure"]}, "then": {"required": ["allow_exposure"], "properties": {"allow_exposure": {"const": true}}}}
          ]
        },
        "evidence": {
          "type": "object", "additionalProperties": false,
          "properties": {
            "render": {"const": true}, "resolution": {"type": "integer", "minimum": 32, "maximum": 4096},
            "min_changed_fraction": {"type": "number", "minimum": 0, "maximum": 1},
            "min_mean_absolute_delta": {"type": "number", "minimum": 0, "maximum": 255},
            "minimum_after_score": {"type": "number", "minimum": 80, "maximum": 100}
          }
        }
      }
    }
    
  • skills/blender-pipeline/editing/schemas/review_package.schema.json2.4 KB7971a4dd55bfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/schemas/source_map.schema.json2.6 KBda389f6649a2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/src/blender_edit_pipeline/__init__.py241 B83a9c021c63fupstream ↗
    """Public contracts for the Blender existing-asset editing pipeline."""
    
    from .contracts import ContractError, EditKind, EditRequest, load_request
    
    __all__ = ["ContractError", "EditKind", "EditRequest", "load_request"]
    __version__ = "0.1.0"
    
  • skills/blender-pipeline/editing/src/blender_edit_pipeline/contracts.py11 KB4705bff079ccupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/__init__.py680 B57570145d28dupstream ↗
    """Allowlisted edit operator dispatch."""
    
    from __future__ import annotations
    
    from typing import Any
    
    from ..contracts import EditKind, EditRequest
    from .geometry import apply_geometry, apply_modeling
    from .material import apply_color, apply_material
    from .scene import apply_scene
    
    
    def apply_edit(request: EditRequest, bpy_module: Any | None = None) -> dict[str, Any]:
        dispatch = {
            EditKind.MATERIAL: apply_material,
            EditKind.COLOR: apply_color,
            EditKind.GEOMETRY: apply_geometry,
            EditKind.MODELING: apply_modeling,
            EditKind.SCENE: apply_scene,
        }
        return dispatch[request.kind](request, bpy_module)
    
    
    __all__ = ["apply_edit"]
    
  • skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/geometry.py37 KB1b09a817770eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/material.py6.5 KBe9df2726be36upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/src/blender_edit_pipeline/operators/scene.py7.1 KBd261989d67e5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/src/blender_edit_pipeline/pipeline.py22 KB31a3ea806b7cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/src/blender_edit_pipeline/qa.py28 KB8457cfaf84a5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/src/blender_edit_pipeline/source_preflight.py7.0 KB40eb4ce57989upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/tests/test_blender_e2e.py17 KB24828babc34dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/tests/test_contracts.py3.1 KB8a97a759b937upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/tests/test_geometry.py4.4 KBddfebe77e2a2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/tests/test_qa.py7.3 KB0b4cde6aa3f3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/editing/tests/test_schemas.py1.4 KBc835d885bbd0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/requirements-knowledge.txt128 B868fd1e1a952upstream ↗
    -r requirements.txt
    
    # Optional semantic knowledge indexing and retrieval.
    qdrant-client>=1.11,<2
    sentence-transformers>=3.0,<6
    
  • skills/blender-pipeline/generation/requirements.txt237 B161eec9ad741upstream ↗
    # Runtime dependencies outside Blender's bundled Python.
    Pillow>=10.4,<13
    requests>=2.32,<3
    Markdown>=3.6,<4  # Optional HTML view of the visual tutorial.
    
    # Blender provides bpy, bpy_extras, and mathutils. Do not install them with pip.
    
  • skills/blender-pipeline/generation/scripts/agent_api_trace.py16 KB3407fdfa74c6upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/agent_trajectory.py61 KB09dad1f05640upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/blender_knowledge_common.py23 KB351deabc1d7aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/blender_version_registry.py25 KB3619c43cde0cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/build_blender_knowledge_index.py19 KB07f59ba8aae4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/build_pipeline_specs.py43 KBed9e8cfc8aeaupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/camera_framing.py4.0 KBa0b481aad375upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/codex_cli_chat_bridge.py9.7 KBa77a9f25d2deupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/embed_markdown_images.py3.4 KB1734c64fbeb4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/extract_workflow_evidence.py17 KB55f283315174upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/generate_code_tutorial.py9.8 KBe9bd4500794cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/generate_rich_tutorial_chunks.py23 KB11bb8259876cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/merge_rich_tutorial_chunks.py9.0 KB88febab67272upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/model_direct_generation_contracts.py16 KBb89ee41d5474upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/model_direct_generation_v3_harness.py155 KB30f8aeeb465eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/prepare_rich_tutorial_evidence.py16 KBfebc255ed8baupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/project_paths.py1.4 KB62e01c5c73bdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/render_asset_six_views_turntable.py130 KBf8729f64d23eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/render_illustrated_tutorial.py11 KB3bb759735adfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/render_knowledge.py60 KBe05a3a4ada73upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/retrieve_blender_knowledge.py16 KB5497bf26f91eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/run_video_replay_main.py53 KB805af6af4394upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/run_video_strict_replay.py163 KB0f0492288f1dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/rw1_static_interchange_framing.py15 KB02ff70b4f466upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/scan_blender_version_ocr.py10 KBe2274fbeb23cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/update_replay_knowledge_base.py27 KB48ad675f7a56upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/video_replay_animation_contract.py21 KB9ec0d150b35aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/video_replay_delivery_contract.py7.9 KB1a77730d2822upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/video_replay_model_client.py31 KB2892e503a933upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/video_replay_paid_api.py79 KBfa2c35130652upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/scripts/video_replay_provider_usage.py75 KB9437d1b00ebcupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_blender_e2e.py8.2 KB8231e183d177upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_camera_framing.py1.3 KBf2a5a9ac192fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_camera_framing_blender.py2.6 KB1905cf38e6e1upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_codex_cli_bridge.py13 KBc0f1970ae34cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_generation_contracts.py6.5 KB44e02f53b173upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_generation_delivery.py31 KB427e3f63e9ebupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_generation_portability.py7.4 KB8b559a291446upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_pipeline_spec_signals.py16 KB8ed6237e9ed6upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_render_device_policy.py8.1 KBdd0f4da33971upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/generation/tests/test_success_knowledge.py15 KBfca3ea2feb89upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/editing.md13 KBcced01ebdfacupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/evidence-and-routing.md7.7 KBa11b60f73765upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/generation.md12 KB861caedc262bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/index.md2.3 KB23374e1c821aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/manifest.json1.4 KB6e26219ba592upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/manifest.schema.json1.7 KB4d4688c5032bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/operations-and-knowledge.md17 KBdce75c514666upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/knowledge/rendering-and-dynamics.md11 KB29734f83a725upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/knowledge/manifest.json230 KB2a9b5e1af466upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/knowledge/public_media_attestations.json12 KBdfbb7d8b4ca5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/knowledge/public_showcase_inventory.json39 KB66a79158c20dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/references/execution-contract.md3.9 KB04aa190292dbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/scripts/export_public_showcase_knowledge.py15 KB5ef9a38a95e4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/scripts/launch_video2blender_reproduction.py54 KB3c740e838ca5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/scripts/reproduce.sh168 B8309232ab53dupstream ↗
    #!/usr/bin/env bash
    set -euo pipefail
    
    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
    
    exec python3 "$SCRIPT_DIR/launch_video2blender_reproduction.py" "$@"
    
  • skills/blender-pipeline/reproduction/scripts/validate_public_knowledge.py9.2 KB712806cf21c4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/reproduction/tests/test_reproduction_contracts.py12 KB7b8276488064upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tests/test_codex_skill_launcher.py12 KBaaa4a1a8e1fcupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tests/test_input_asset_topology.py3.8 KBd7ec61812e67upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tests/test_knowledge_contract.py4.6 KB8f601d3a5fc9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tests/test_root_launchers.py38 KB33f72528ff4aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tests/test_router_and_package.py3.3 KBaf83314e64daupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/agents/openai.yaml310 Baf1fac7ecdc5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/references/blender-capability-rubric.md2.1 KBf2f971e2594aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/references/evidence-ledger.md1.2 KBf04f144eae29upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/references/markdown-layout.md1.8 KB4935253cf6ecupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/references/output-contract.md5.6 KBc16278362a62upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/references/profiles-and-evidence.md3.3 KBff0a124f58fdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/requirements.txt72 Bde88d4eeccc5upstream ↗
    Pillow>=10.4,<13
    jsonschema>=4.23,<5
    requests>=2.32,<3
    Markdown>=3.6,<4
    
  • skills/blender-pipeline/tutorial-extraction/schemas/manifest.schema.json2.7 KB928fcf748d31upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/schemas/steps.schema.json2.5 KB9d44b041c2c4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/scripts/extract_video_tutorial.py9.1 KB6b8aa807a8b4upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/scripts/legacy_rich_tutorial_pipeline.py27 KB46077bee1437upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/scripts/prepare_video.py5.5 KB7daf379af81fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/scripts/tutorial_extraction_core.py172 KBa7479e57d8c7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/scripts/validate_tutorial_package.py33 KB85b06b5423a2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/scripts/validate_visual_package.py9.1 KBabaddfd1f591upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/scripts/visual_tutorial_pipeline.py36 KB5f154980bd43upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/tests/test_audio_stream_preflight.py2.9 KB79cbe590332dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/tests/test_legacy_rich_tutorial_pipeline.py17 KB63a9b60fa5abupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • skills/blender-pipeline/tutorial-extraction/tests/test_visual_tutorial_pipeline.py22 KB2e545ba1cdb5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/freedomintelligence-blenderlore-skills-blender-pipeline.md

// REPO STATS

100 stars
0 open issues
Last commit: 1mo ago