asset-packager
Automated asset packaging—converts validated PNG + IDF JSON into complete production bundle (context.md, tokens.json, usage.md). Eliminates 30 manual file generations across 10 assets.
Best use case
asset-packager is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Automated asset packaging—converts validated PNG + IDF JSON into complete production bundle (context.md, tokens.json, usage.md). Eliminates 30 manual file generations across 10 assets.
Teams using asset-packager should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/asset-packager/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How asset-packager Compares
| Feature / Agent | asset-packager | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Automated asset packaging—converts validated PNG + IDF JSON into complete production bundle (context.md, tokens.json, usage.md). Eliminates 30 manual file generations across 10 assets.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Asset-Packager Skill
## Purpose
Automates asset packaging after validation. Input: validated PNG + IDF. Output: complete directory with context/tokens/usage files + production file copy + git commit. Replaces 15 min manual work with 2 min automated execution.
## Input Requirements
```json
{
"asset_id": "ASSET-3",
"asset_name": "Nocturnal Canopy Pattern",
"validated_png": "/downloads/asset-3-validated.png",
"compliance_score": 92,
"idf_data": {
"colors": {"background": "#1A1714", "wattle_gold": "#D4A84B"},
"specimens": ["Eucalyptus", "Wattle", "Banksia"],
"dimensions": {"width": 512, "height": 512},
"mode": "Gallery",
"purpose": "Seamless background pattern"
}
}
```
## Generated Files
### 1. context.md
Narrative philosophy explaining specimen choices, geometric principles, mode context.
**Template:**
```markdown
# Asset [N]: [Name]
## Narrative
[Victorian naturalist discovery story based on specimens]
## Specimens
[List with taxonomic significance]
## Mode Context
Gallery: [Warm/theatrical interpretation]
Laboratory: [Clinical/analytical interpretation]
## Purpose
[UI placement and compositional role]
```
### 2. tokens.json
Machine-readable design specifications.
**Structure:**
```json
{
"asset_id": "ASSET-3",
"background": "#1A1714",
"palette": {
"primary": ["#C45C4B", "#D4A84B"],
"accents": ["#7A9E82", "#D4885C"]
},
"dimensions": {"width": 512, "height": 512, "format": "PNG"},
"density_zones": {
"upper_left": {"coverage": "18%"},
"central": {"coverage": "65%"}
},
"specimens": [...],
"mode": "Gallery",
"compliance_score": 92
}
```
### 3. usage.md
CSS implementation with responsive behavior, opacity ranges, placement guidelines.
**Template:**
```markdown
# Usage Guidelines
## CSS Implementation
\`\`\`css
.asset-[name] {
background-image: url('/assets/[path]');
background-size: [cover|contain|repeat];
background-position: center;
}
/* Opacity by context */
.gallery-hero { opacity: 0.85; }
.gallery-content { opacity: 0.70; }
.dashboard { opacity: 0.60; }
\`\`\`
## Responsive Behavior
- Desktop: Full resolution
- Tablet: Scale proportionally
- Mobile: [Specific guidance]
## Component Integration
Recommended for: [Components list]
Avoid for: [Contexts where inappropriate]
```
## Automation Steps
1. **Create Directory**
```bash
mkdir -p /assets/ASSET-[N]-[slug]/
```
2. **Generate context.md**
- Extract specimens from IDF
- Build narrative using specimen → taxonomic significance mapping
- Insert mode context (Gallery/Laboratory)
3. **Generate tokens.json**
- Convert IDF to structured JSON
- Add compliance metadata
- Format for machine parsing
4. **Generate usage.md**
- Build CSS template with asset path
- Add opacity recommendations based on mode
- List component integration targets
5. **Copy Production File**
```bash
cp [validated_png] /frontend/public/assets/[category]/[filename]
```
Categories: wallpapers, patterns, specimens, icons
6. **Git Commit**
```bash
git add /assets/ASSET-[N]-* /frontend/public/assets/[category]/
git commit -m "feat(assets): Add Asset [N] [name] - [score]/100"
```
## Integration Points
**Flash-Sidekick:**
- Call `generate_idf` on validated PNG → extract design tokens
- Call `quick_summarize` on specimen list → generate narrative
**Auto-Validator:**
- Trigger: score ≥90 → auto-package
- Input: validation JSON + PNG path
**Claude Code:**
- Delegates file operations and git commits
- Verifies directory structure creation
## Usage Example
```python
# After auto-validation passes
packager_result = asset_packager.run(
asset_id="ASSET-3",
validation_result=auto_validator_output,
png_path="/downloads/asset-3-validated.png"
)
# Output:
# Created: /assets/ASSET-3-nocturnal-canopy/{context,tokens,usage}
# Copied: /frontend/public/assets/patterns/nocturnal-canopy-tile-512.png
# Committed: feat(assets): Add Asset 3 Nocturnal Canopy - 92/100
```
## Efficiency Gain
**Before:** 15 min per asset × 10 assets = 150 min
**After:** 2 min per asset × 10 assets = 20 min
**Savings:** 130 min (87% time reduction)
## File Naming Convention
**Assets Directory:** `ASSET-[N]-[kebab-case-name]/`
**Production Files:**
- Wallpapers: `texture-[mode]-[name]-[width].png`
- Patterns: `[name]-tile-[size].png`
- Specimens: `specimen-[name]-[style]-[size].png`
- Icons: `[name]-[purpose]-[size].png`
---
*Eliminates repetitive packaging work. Validated asset → production bundle in 2 minutes.*Related Skills
asset-tracking
Use when managing asset metadata, dependencies, and delivery workflows across teams.
asset-forge
Creates new skills, rules, and MCPs for ai-driven-dev-system or project-specific use. Use when user requests a new reusable component, wants to add coding standards, needs to document a workflow, or asks to create a skill or rule.
asset-bundles
Create and configure Databricks Asset Bundles (DABs) with best practices for multi-environment deployments. Use when working with: (1) Creating new DAB projects, (2) Adding resources (dashboards, pipelines, jobs, alerts), (3) Configuring multi-environment deployments, (4) Setting up permissions, (5) Deploying or running bundle resources
asset-optimization
Asset optimization skill for mesh and texture budgets.
create-an-asset
Generate tailored sales assets (landing pages, decks, one-pagers, workflow demos) from your deal context. Describe your prospect, audience, and goal — get a polished, branded asset ready to share with customers.
assets-organizing
Organize all outputs from slash commands and subagents in assets/ directory by topics, date format, and slugs.
assets-delete
Delete the assets at paths from the project. Does AssetDatabase.Refresh() at the end. Use 'assets-find' tool to find assets before deleting.
bgo
Automates the complete Blender build-go workflow, from building and packaging your extension/add-on to removing old versions, installing, enabling, and launching Blender for quick testing and iteration.
large-data-with-dask
Specific optimization strategies for Python scripts working with larger-than-memory datasets via Dask.
langsmith-fetch
Debug LangChain and LangGraph agents by fetching execution traces from LangSmith Studio. Use when debugging agent behavior, investigating errors, analyzing tool calls, checking memory operations, or examining agent performance. Automatically fetches recent traces and analyzes execution patterns. Requires langsmith-fetch CLI installed.
langchain-tool-calling
How chat models call tools - includes bind_tools, tool choice strategies, parallel tool calling, and tool message handling
langchain-notes
LangChain 框架学习笔记 - 快速查找概念、代码示例和最佳实践。包含 Core components、Middleware、Advanced usage、Multi-agent patterns、RAG retrieval、Long-term memory 等主题。当用户询问 LangChain、Agent、RAG、向量存储、工具使用、记忆系统时使用此 Skill。