@salesforce/afv-skills 1.8.0 → 1.9.0

package/skills/generating-mermaid-diagrams/scripts/query-org-metadata.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+Query Salesforce org for ERD metadata enrichment.
+
+Retrieves:
+1. Record counts for LDV detection (>2M = LDV)
+2. OWD (Org-Wide Default) sharing settings
+3. Object type (Standard/Custom/External)
+
+Usage:
+    python3 query-org-metadata.py --objects Account,Contact,Invoice__c --target-org myorg
+    python3 query-org-metadata.py --objects Account,Contact --target-org myorg --output table
+    python3 query-org-metadata.py --objects Account --target-org myorg --output json
+
+Output:
+    JSON or table with object metadata for diagram generation
+"""
+
+import subprocess
+import json
+import sys
+import argparse
+from typing import Optional
+
+LDV_THRESHOLD = 2_000_000  # 2 million records
+
+
+def run_sf_command(cmd: list[str], timeout: int = 30) -> Optional[dict]:
+    """Run an sf CLI command and return parsed JSON result."""
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        if result.returncode == 0:
+            return json.loads(result.stdout)
+    except subprocess.TimeoutExpired:
+        pass
+    except json.JSONDecodeError:
+        pass
+    except Exception:
+        pass
+    return None
+
+
+def query_record_count(sobject: str, target_org: str) -> int:
+    """Query record count using sf data query."""
+    # External objects don't support COUNT()
+    if sobject.endswith("__x"):
+        return -1
+
+    cmd = [
+        "sf", "data", "query",
+        "--query", f"SELECT COUNT() FROM {sobject}",
+        "--target-org", target_org,
+        "--json"
+    ]
+
+    data = run_sf_command(cmd)
+    if data:
+        return data.get("result", {}).get("totalSize", -1)
+    return -1
+
+
+def query_object_describe(sobject: str, target_org: str) -> dict:
+    """Get object metadata (label, custom flag) via sobject describe."""
+    cmd = [
+        "sf", "sobject", "describe",
+        "--sobject", sobject,
+        "--target-org", target_org,
+        "--json"
+    ]
+
+    data = run_sf_command(cmd)
+    if data:
+        result_data = data.get("result", {})
+        return {
+            "is_custom": result_data.get("custom", False),
+            "key_prefix": result_data.get("keyPrefix", ""),
+            "label": result_data.get("label", sobject),
+        }
+    return {}
+
+
+def query_owd_bulk(objects: list[str], target_org: str) -> dict[str, dict]:
+    """
+    Query OWD for multiple objects using Tooling API EntityDefinition.
+
+    This is the correct way to get OWD - sf sobject describe returns null
+    for sharingModel, but EntityDefinition via Tooling API works.
+    """
+    # Build IN clause for SOQL
+    quoted_objects = ", ".join([f"'{obj}'" for obj in objects])
+    query = f"SELECT QualifiedApiName, InternalSharingModel, ExternalSharingModel FROM EntityDefinition WHERE QualifiedApiName IN ({quoted_objects})"
+
+    cmd = [
+        "sf", "data", "query",
+        "--query", query,
+        "--target-org", target_org,
+        "--use-tooling-api",
+        "--json"
+    ]
+
+    data = run_sf_command(cmd, timeout=60)
+    result = {}
+
+    if data:
+        records = data.get("result", {}).get("records", [])
+        for record in records:
+            api_name = record.get("QualifiedApiName", "")
+            result[api_name] = {
+                "internal_owd": record.get("InternalSharingModel", "Unknown"),
+                "external_owd": record.get("ExternalSharingModel", "Unknown"),
+            }
+
+    return result
+
+
+def get_object_type(sobject: str, describe: dict) -> str:
+    """Determine object type: STD, CUST, or EXT."""
+    if sobject.endswith("__x"):
+        return "EXT"
+    elif sobject.endswith("__c") or describe.get("is_custom"):
+        return "CUST"
+    return "STD"
+
+
+def format_ldv(count: int) -> str:
+    """Format record count for LDV display."""
+    if count < 0:
+        return ""
+    if count >= LDV_THRESHOLD:
+        if count >= 1_000_000:
+            return f"LDV[~{count // 1_000_000}M]"
+        else:
+            return f"LDV[~{count // 1_000}K]"
+    return ""
+
+
+def format_owd(sharing_model: str) -> str:
+    """Format OWD for display."""
+    owd_map = {
+        "Private": "Private",
+        "Read": "Read",
+        "ReadWrite": "ReadWrite",
+        "ReadWriteTransfer": "Full",
+        "ControlledByParent": "Parent",
+        "FullAccess": "Full",
+        "Unknown": "Unknown"
+    }
+    return owd_map.get(sharing_model, sharing_model)
+
+
+def format_count(count: int) -> str:
+    """Format record count with commas."""
+    if count < 0:
+        return "N/A"
+    return f"{count:,}"
+
+
+def print_table_output(results: dict) -> None:
+    """Print results as formatted table."""
+    print()
+    print("=" * 78)
+    print(f"{'Object':<25} {'Type':<6} {'Records':<14} {'LDV':<12} {'OWD':<15}")
+    print("-" * 78)
+
+    for obj, data in results.items():
+        count_str = format_count(data['record_count'])
+        ldv = data['ldv_indicator'] or "-"
+        owd = f"OWD:{data['owd']}"
+        print(f"{obj:<25} {data['object_type']:<6} {count_str:<14} {ldv:<12} {owd:<15}")
+
+    print("=" * 78)
+    print()
+
+
+def print_mermaid_hints(results: dict) -> None:
+    """Print Mermaid flowchart style hints."""
+    print("Mermaid Style Hints:")
+    print("-" * 40)
+
+    for obj, data in results.items():
+        obj_type = data['object_type']
+        if obj_type == "STD":
+            color = "fill:#bae6fd,stroke:#0369a1"
+        elif obj_type == "CUST":
+            color = "fill:#fed7aa,stroke:#c2410c"
+        else:  # EXT
+            color = "fill:#a7f3d0,stroke:#047857"
+
+        # Build label parts
+        label_parts = []
+        if data['ldv_indicator']:
+            label_parts.append(data['ldv_indicator'])
+        label_parts.append(f"OWD:{data['owd']}")
+
+        label = f"{obj}<br/>{' | '.join(label_parts)}"
+        safe_id = obj.replace("__", "_")
+
+        print(f'    {safe_id}["{label}"]')
+        print(f"    style {safe_id} {color},color:#1f2937")
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Query Salesforce org for ERD metadata (LDV, OWD, object type)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    %(prog)s --objects Account,Contact,Opportunity --target-org myorg
+    %(prog)s --objects Account,Invoice__c --target-org myorg --output table
+    %(prog)s --objects Account --target-org myorg --mermaid
+        """
+    )
+    parser.add_argument(
+        "--objects", "-o",
+        required=True,
+        help="Comma-separated object API names (e.g., Account,Contact,Invoice__c)"
+    )
+    parser.add_argument(
+        "--target-org", "-u",
+        required=True,
+        help="Salesforce org alias or username"
+    )
+    parser.add_argument(
+        "--output", "-f",
+        default="table",
+        choices=["json", "table"],
+        help="Output format (default: table)"
+    )
+    parser.add_argument(
+        "--mermaid", "-m",
+        action="store_true",
+        help="Include Mermaid style hints in output"
+    )
+
+    args = parser.parse_args()
+
+    objects = [o.strip() for o in args.objects.split(",")]
+    results = {}
+
+    # Show progress for table output
+    if args.output == "table":
+        print(f"\nQuerying {len(objects)} objects from org: {args.target_org}")
+        print("-" * 50)
+
+    # Bulk query OWD for all objects at once (much faster)
+    if args.output == "table":
+        print("  [0] Querying OWD via Tooling API...", end=" ", flush=True)
+    owd_data = query_owd_bulk(objects, args.target_org)
+    if args.output == "table":
+        print(f"OK ({len(owd_data)} found)")
+
+    for i, obj in enumerate(objects, 1):
+        if args.output == "table":
+            print(f"  [{i}/{len(objects)}] Querying {obj}...", end=" ", flush=True)
+
+        count = query_record_count(obj, args.target_org)
+        describe = query_object_describe(obj, args.target_org)
+        obj_type = get_object_type(obj, describe)
+
+        # Get OWD from bulk query result
+        obj_owd = owd_data.get(obj, {})
+        internal_owd = obj_owd.get("internal_owd", "Unknown")
+
+        results[obj] = {
+            "record_count": count,
+            "ldv_indicator": format_ldv(count),
+            "object_type": obj_type,
+            "owd": format_owd(internal_owd),
+            "external_owd": format_owd(obj_owd.get("external_owd", "Unknown")),
+            "label": describe.get("label", obj),
+        }
+
+        if args.output == "table":
+            status = "OK" if describe else "WARN"
+            print(status)
+
+    # Output results
+    if args.output == "json":
+        print(json.dumps(results, indent=2))
+    else:
+        print_table_output(results)
+        if args.mermaid:
+            print_mermaid_hints(results)
+
+
+if __name__ == "__main__":
+    main()

package/skills/generating-visual-diagrams/CREDITS.md

@@ -0,0 +1,80 @@
+# Credits & Acknowledgments
+
+This skill leverages cutting-edge AI technologies and tools to enable visual content generation in Salesforce development workflows.
+
+---
+
+## Technologies & Tools
+
+### Google Gemini
+
+Key capabilities:
+- Gemini 3 Pro multimodal AI model
+- Image generation via Nano Banana Pro extension
+- Code review and analysis capabilities
+- Documentation research and summarization
+
+### Gemini CLI
+
+Key features:
+- Command-line access to Gemini models
+- Extension support (Nano Banana)
+- Non-interactive mode with --yolo flag
+- JSON output for programmatic use
+
+### Nano Banana Pro
+
+Gemini image generation extension.
+
+Key features:
+- High-quality image generation
+- ERD and diagram creation
+- UI/UX mockup generation
+- Architecture visualization
+
+---
+
+## Display Technologies
+
+### timg
+
+Terminal image viewer.
+
+Key features:
+- Kitty graphics protocol support
+- Multiple format support (PNG, JPG, GIF)
+- Inline terminal display
+
+### Kitty Graphics Protocol
+
+High-fidelity image rendering protocol for modern terminals.
+
+Key features:
+- High-fidelity image display in terminals
+- Supported by Ghostty, Kitty, WezTerm
+- Enables visual content in CLI workflows
+
+### Ghostty Terminal
+
+Modern GPU-accelerated terminal emulator.
+
+Key features:
+- Kitty graphics protocol support
+- Cross-platform (macOS, Linux)
+- High performance rendering
+
+---
+
+## Salesforce Resources
+
+### Salesforce Lightning Design System (SLDS)
+
+- Design patterns for LWC mockups
+- Color palettes and typography
+- Component specifications
+
+### Salesforce Developers Platform
+
+- API documentation
+- Best practices guides
+- Platform architecture references

package/skills/generating-visual-diagrams/README.md

@@ -0,0 +1,83 @@
+# generating-visual-diagrams
+
+AI-powered visual content generation for Salesforce development. Generate ERD diagrams, LWC mockups, and architecture visuals using Gemini 3 Pro Image (Nano Banana Pro).
+
+## Features
+
+- **Visual ERD Generation**: Create actual rendered ERD diagrams (not just Mermaid code)
+- **LWC/UI Mockups**: Generate wireframes and component mockups following SLDS
+- **Gemini Code Review**: Parallel code review while Claude continues working
+- **Documentation Research**: Parallel Salesforce documentation research via Gemini
+
+## Prerequisites
+
+**IMPORTANT**: Run the prerequisites check before using this skill:
+
+```bash
+scripts/check-prerequisites.sh
+```
+
+| Requirement | Description | How to Install |
+|-------------|-------------|----------------|
+| **Ghostty Terminal** | Required for Kitty graphics protocol | Download from the Ghostty website |
+| **GEMINI_API_KEY** | Personal API key for Nano Banana Pro | Generate via Google AI Studio |
+| **Gemini CLI** | Command-line interface for Gemini | `npm install -g @google/gemini-cli` |
+| **Nano Banana Extension** | Image generation extension | `gemini extensions install nanobanana` |
+| **timg** | Terminal image viewer with Kitty support | `brew install timg` |
+
+## Quick Start
+
+### 1. Set up your API key
+
+Add to `~/.zshrc`:
+```bash
+export GEMINI_API_KEY="your-personal-api-key"
+export NANOBANANA_MODEL=gemini-3-pro-image-preview
+```
+
+### 2. Invoke the skill
+
+```
+Skill: generating-visual-diagrams
+Request: "Generate an ERD diagram showing Account, Contact, and Opportunity relationships"
+```
+
+### 3. View the result
+
+Images are displayed inline using Kitty graphics protocol (Ghostty) or via Claude's multimodal vision using the Read tool.
+
+## Use Cases
+
+| Use Case | Example Request |
+|----------|-----------------|
+| ERD Diagrams | "Generate a visual ERD for Account, Contact, Opportunity" |
+| LWC Mockups | "Create a mockup for an Account list datatable component" |
+| Code Review | "Get Gemini's review of this Apex trigger" |
+| Doc Research | "Research the Flow best practices in Salesforce docs" |
+
+## Cross-Skill Integration
+
+| Related Skill | When to Use |
+|---------------|-------------|
+| generating-mermaid-diagrams | Convert Mermaid to visual rendering |
+| generating-custom-object | Query object/field data before generating ERDs |
+| generating-lwc-components | Generate mockups for LWC components |
+| generating-apex | Review Apex code via Gemini sub-agent |
+
+## Documentation
+
+- [Gemini CLI Setup](references/gemini-cli-setup.md)
+
+## Security Notes
+
+**NEVER commit your GEMINI_API_KEY to version control**
+
+- Store API key in `~/.zshrc` only (not in project files)
+- The key is personal and tied to your Google account billing
+
+## Requirements
+
+- Ghostty terminal (for Kitty graphics)
+- Gemini CLI with Nano Banana extension
+- GEMINI_API_KEY environment variable
+- timg (for terminal image display)

package/skills/generating-visual-diagrams/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: generating-visual-diagrams
+description: "AI-powered image generation for Salesforce visuals via Nano Banana Pro. Use this skill when the user needs rendered PNG/SVG output such as visual ERDs (Entity Relationship Diagrams), UI mockups, wireframes, or architecture illustrations. TRIGGER when: user asks for PNG/SVG output, UI mockups, wireframes, visual ERDs, or says \"generate image\" / \"create mockup\". DO NOT TRIGGER when: text-based Mermaid diagrams (use generating-mermaid-diagrams), or non-visual documentation tasks."
+license: MIT
+metadata:
+  version: "1.0"
+---
+
+# generating-visual-diagrams: Salesforce Visual AI Skill
+
+Use this skill when the user needs **rendered visuals**, not text diagrams: ERDs, UI mockups, architecture illustrations, slide-ready images, or image edits using Nano Banana Pro.
+
+## Scope
+
+**In scope:**
+- PNG / SVG-style rendered image output
+- Visual ERDs and architecture diagrams
+- LWC or Experience Cloud mockups / wireframes
+- Image edits on previously generated visuals
+
+**Out of scope — delegate instead:**
+- Mermaid or text-only diagrams → [generating-mermaid-diagrams](../generating-mermaid-diagrams/SKILL.md)
+- Object / field metadata discovery for ERDs → [generating-custom-object](../generating-custom-object/SKILL.md) or [generating-custom-field](../generating-custom-field/SKILL.md)
+- LWC implementation after the mockup is approved → [generating-lwc-components](../generating-lwc-components/SKILL.md)
+- Apex review / implementation → [generating-apex](../generating-apex/SKILL.md)
+
+---
+
+## Hard Gate: Prerequisites First
+
+Run the prerequisites check before using the skill:
+
+```bash
+scripts/check-prerequisites.sh
+```
+
+If prerequisites fail, stop and route the user to setup guidance in:
+- [references/gemini-cli-setup.md](references/gemini-cli-setup.md)
+
+---
+
+## Required Inputs
+
+Ask for or infer before generating:
+
+| Input | Default if not provided |
+|---|---|
+| Image type | ERD |
+| Subject scope and key entities / systems | Ask the user |
+| Target quality | Draft (1K) |
+| Preferred style | architect.salesforce.com aesthetic |
+| Aspect ratio | Default (no override) |
+| Quick mode or interview mode | Interview mode |
+
+---
+
+## Interview-First Workflow
+
+Unless the user asks for **quick / simple / just generate**, ask clarifying questions first using the question bank in [references/interview-questions.md](references/interview-questions.md).
+
+| Request type | Ask about |
+|---|---|
+| ERD / schema | objects, visual style, purpose, extras |
+| UI mockup | component type, object/context, device/layout, style |
+| architecture image | systems, boundaries, protocols, emphasis |
+| image edit | what to keep, what to change, output quality |
+
+**Quick mode defaults** (triggered by "quick", "simple", "just generate", "fast"):
+- professional style, 1K draft, legend included, one image first then iterate
+
+---
+
+## Recommended Workflow
+
+### 1. Run prerequisites check
+Run `scripts/check-prerequisites.sh` and confirm all required tools pass before proceeding.
+
+### 2. Gather inputs
+- object list / metadata (delegate to `generating-custom-object` / `generating-custom-field` if needed)
+- purpose: draft vs presentation vs documentation
+- desired aesthetic — read [references/architect-aesthetic-guide.md](references/architect-aesthetic-guide.md) for ERDs
+- aspect ratio / resolution
+
+### 3. Run interview or use quick-mode defaults
+Load [references/interview-questions.md](references/interview-questions.md) for the matching question set (ERD, LWC, architecture, code review).
+
+### 4. Build a concrete prompt
+Good prompts specify subject, composition, color treatment, labels/legends, and output quality goal.
+
+### 5. Generate a fast draft at 1K
+```bash
+gemini --yolo "/generate 'Your prompt here'"
+```
+Open the result and review layout before spending on higher resolution.
+
+### 6. Iterate using edits
+```bash
+gemini --yolo "/edit 'Specific change instruction'"
+```
+Use `/edit` for small adjustments — cheaper than regenerating. See [references/iteration-workflow.md](references/iteration-workflow.md).
+
+### 7. Generate final at 2K/4K using the Python script
+Run `scripts/generate_image.py` when layout is confirmed:
+```bash
+uv run scripts/generate_image.py -p "Refined prompt" -f "output.png" -r 4K
+```
+
+### 8. Error recovery
+- If `gemini --yolo` returns no image: re-run once; if it fails again, fall back to the Python script path.
+- If the Python script fails with `GEMINI_API_KEY not found`: verify the key is exported in your shell profile (`~/.zshrc` on macOS/zsh, `~/.bashrc` on Linux) and the terminal session is refreshed.
+- If the extension is missing: run `gemini extensions install nanobanana` and re-run the prerequisites check.
+
+---
+
+## Default Style Guidance
+
+For ERDs, default to the **architect.salesforce.com** aesthetic unless the user asks otherwise:
+- dark border + light fill cards
+- cloud-specific accent colors
+- clean labels and relationship lines
+- presentation-ready whitespace and hierarchy
+
+Full style specification: [references/architect-aesthetic-guide.md](references/architect-aesthetic-guide.md)
+
+---
+
+## Common Patterns
+
+| Pattern | Default approach |
+|---|---|
+| visual ERD | get metadata if available, then render a draft first |
+| LWC mockup | load [assets/lwc/data-table.md](assets/lwc/data-table.md), [assets/lwc/record-form.md](assets/lwc/record-form.md), or [assets/lwc/dashboard-card.md](assets/lwc/dashboard-card.md) for the matching template |
+| architecture illustration | load [assets/architecture/integration-flow.md](assets/architecture/integration-flow.md); emphasize systems and flows |
+| image refinement | use `/edit` for small changes before regenerating |
+| final production asset | switch to script-driven 2K/4K generation via `scripts/generate_image.py` |
+| Apex / LWC code review | load [assets/review/apex-review.md](assets/review/apex-review.md) or [assets/review/lwc-review.md](assets/review/lwc-review.md) for the review prompt template |
+
+---
+
+## Output Expectations
+
+Deliverables produced by this skill:
+
+- **Draft image** (`<name>.png`) — 1K resolution rendered via `gemini --yolo "/generate ..."` for layout review
+- **Final image** (`<name>.png`) — 2K or 4K resolution rendered via `scripts/generate_image.py` once composition is approved
+- **Edit iteration** (`<name>.png`) — incremental refinement via `gemini --yolo "/edit ..."` without full regeneration
+
+After delivering each image:
+- Open the file in Preview or attach it in the session for multimodal review
+- Ask the user whether to iterate on layout, labeling, or color before finalizing
+- Only proceed to high-res output after draft composition is confirmed
+
+---
+
+## Rules / Constraints
+
+| Rule | Rationale |
+|---|---|
+| Always run prerequisites check before any generation | Missing tools produce silent failures |
+| Always draft at 1K before generating at 4K | Cost and time savings; composition changes at high res are wasteful |
+| Use `/edit` for incremental changes, not full regeneration | Cheaper and faster for small adjustments |
+| Never commit `GEMINI_API_KEY` to version control | Key is personal and tied to billing |
+| Delegate text diagrams to `generating-mermaid-diagrams` | This skill owns rendered images only |
+
+---
+
+## Gotchas
+
+| Issue | Resolution |
+|---|---|
+| Edit not applying correctly | Be specific: reference existing elements by name; one change at a time |
+| 4K output looks different from 1K draft | Use exact same prompt text; minor variations are normal model behavior |
+| `gemini --yolo` fails silently | Check that the Nano Banana extension is installed: `gemini extensions list` |
+| Image dimensions wrong | Set `--aspect-ratio` explicitly in `scripts/generate_image.py` using `-a "16:9"` |
+| RGBA image causes errors in Python script | Script auto-converts RGBA→RGB; ensure Pillow is installed via `uv` |
+
+---
+
+## Cross-Skill Integration
+
+| Need | Delegate to | Reason |
+|---|---|---|
+| Mermaid first draft or text diagram | [generating-mermaid-diagrams](../generating-mermaid-diagrams/SKILL.md) | faster structural diagramming |
+| Object / field discovery for ERD | [generating-custom-object](../generating-custom-object/SKILL.md) / [generating-custom-field](../generating-custom-field/SKILL.md) | accurate schema grounding |
+| Turn mockup into real LWC component | [generating-lwc-components](../generating-lwc-components/SKILL.md) | implementation after design |
+| Apex review / implementation | [generating-apex](../generating-apex/SKILL.md) | code-quality follow-up |
+
+---
+
+## Reference File Index
+
+| File | When to read |
+|---|---|
+| [references/gemini-cli-setup.md](references/gemini-cli-setup.md) | Prerequisites fail — Gemini CLI / Nano Banana setup guidance |
+| [references/interview-questions.md](references/interview-questions.md) | Step 3 — load question set matching the request type |
+| [references/iteration-workflow.md](references/iteration-workflow.md) | Step 6 — draft-to-final iteration patterns and cost tips |
+| [references/architect-aesthetic-guide.md](references/architect-aesthetic-guide.md) | Step 4 — ERD color palettes, box styles, prompt templates |
+| [references/examples-index.md](references/examples-index.md) | Step 4 — example prompts for ERD, LWC, architecture, code review |
+| [assets/erd/core-objects.md](assets/erd/core-objects.md) | Step 4 — prompt template for core CRM objects (Account, Contact, Opportunity, Case) |
+| [assets/erd/custom-objects.md](assets/erd/custom-objects.md) | Step 4 — prompt template for custom object ERDs |
+| [assets/lwc/data-table.md](assets/lwc/data-table.md) | Step 4 — prompt template for lightning-datatable mockups |
+| [assets/lwc/record-form.md](assets/lwc/record-form.md) | Step 4 — prompt template for lightning-record-form mockups |
+| [assets/lwc/dashboard-card.md](assets/lwc/dashboard-card.md) | Step 4 — prompt template for dashboard card / metric tile mockups |
+| [assets/architecture/integration-flow.md](assets/architecture/integration-flow.md) | Step 4 — prompt template for integration architecture diagrams |
+| [assets/review/apex-review.md](assets/review/apex-review.md) | Step 4 — Gemini review prompt template for Apex code |
+| [assets/review/lwc-review.md](assets/review/lwc-review.md) | Step 4 — Gemini review prompt template for LWC components |
+| [scripts/check-prerequisites.sh](scripts/check-prerequisites.sh) | Step 1 — run to verify all required tools are installed |
+| [scripts/generate_image.py](scripts/generate_image.py) | Step 7 — run for 2K/4K resolution output and image editing with resolution control |