Skip to content

oberconcejo/VS-CODE / .agents/skills/design

design

Verified

Comprehensive design skill: brand identity, design tokens, UI styling, logo generation (55 styles, Gemini, Atlas Cloud, or MuAPI AI), corporate identity program (50 deliverables, CIP mockups), HTML presentations (Chart.js), banner design (22 styles, social/ads/web/print), icon design (15 styles, SVG, Gemini 3.1 Pro), social photos (HTML→screenshot, multi-platform). Actions: design logo, create CIP, generate mockups, build slides, design banner, generate icon, create social photos, social media images, brand identity, design system. Platforms: Facebook, Twitter, LinkedIn, YouTube, Instagram, Pinterest, TikTok, Threads, Google Ads.

FileKindSize
SKILL.mdskill md13.9 KB
data/cip/deliverables.csvother13.1 KB
data/cip/industries.csvother4.8 KB
data/cip/mockup-contexts.csvother5.1 KB
data/cip/styles.csvother5.8 KB
data/icon/styles.csvother2.2 KB
data/logo/colors.csvother10.4 KB
data/logo/industries.csvother13.0 KB
data/logo/styles.csvother13.4 KB
references/banner-sizes-and-styles.mdmarkdown4.9 KB
references/cip-deliverable-guide.mdmarkdown1.7 KB
references/cip-design.mdmarkdown4.3 KB
references/cip-prompt-engineering.mdmarkdown2.4 KB
references/cip-style-guide.mdmarkdown2.3 KB
references/design-routing.mdmarkdown5.6 KB
references/icon-design.mdmarkdown4.1 KB
references/logo-color-psychology.mdmarkdown3.3 KB
references/logo-design.mdmarkdown4.2 KB
references/logo-prompt-engineering.mdmarkdown4.2 KB
references/logo-style-guide.mdmarkdown3.4 KB
references/slides-copywriting-formulas.mdmarkdown2.5 KB
references/slides-create.mdmarkdown153 B
references/slides-html-template.mdmarkdown8.8 KB
references/slides-layout-patterns.mdmarkdown3.6 KB
references/slides-strategies.mdmarkdown2.6 KB
references/slides.mdmarkdown1.7 KB
references/social-photos-design.mdmarkdown11.0 KB
scripts/cip/core.pyscript7.9 KB
scripts/cip/generate.pyscript20.1 KB
scripts/cip/render-html.pyscript13.6 KB
scripts/cip/search.pyscript4.4 KB
scripts/icon/generate.pyscript18.6 KB
scripts/logo/core.pyscript5.9 KB
scripts/logo/generate.pyscript28.4 KB
scripts/logo/search.pyscript4.6 KB
scripts/logo/tests/test_generate.pyscript16.0 KB
scripts/tests/test_cip_generate.pyscript4.9 KB
scripts/tests/test_icon_generate.pyscript6.9 KB

scripts/logo/tests/test_generate.py

View on GitHub
import importlib.util
import io
import os
import sys
import tempfile
import unittest
from pathlib import Path
from types import ModuleType, SimpleNamespace
from unittest.mock import Mock, call, patch

MODULE_PATH = Path(__file__).parents[1] / "generate.py"


def _load_module():
    spec = importlib.util.spec_from_file_location("logo_generate", MODULE_PATH)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


logo_generate = _load_module()

JPEG = b"\xff\xd8\xff\xe0jpeg-bytes"
PNG = b"\x89PNG\r\n\x1a\npng-bytes"


def _image_response(mime_type, data):
    part = SimpleNamespace(inline_data=SimpleNamespace(mime_type=mime_type, data=data))
    return SimpleNamespace(
        candidates=[SimpleNamespace(content=SimpleNamespace(parts=[part]))]
    )


def _fake_genai(client):
    """sys.modules entries for an offline google.genai whose Client is client."""
    types = ModuleType("google.genai.types")
    types.GenerateContentConfig = types.ImageConfig = types.SafetySetting = dict
    genai = ModuleType("google.genai")
    genai.Client = lambda api_key: client
    genai.types = types
    google = ModuleType("google")
    google.genai = genai
    return {"google": google, "google.genai": genai, "google.genai.types": types}


class AtlasGenerationTests(unittest.TestCase):
    @patch.object(logo_generate, "_download_atlas_image")
    @patch.object(logo_generate.time, "sleep")
    @patch.object(logo_generate, "_json_request")
    def test_atlas_submits_once_and_polls_until_completed(
        self, json_request, sleep, download
    ):
        json_request.side_effect = [
            {"code": 200, "data": {"id": "pred-123", "status": "created"}},
            {"code": 200, "data": {"id": "pred-123", "status": "processing"}},
            {
                "code": 200,
                "data": {
                    "id": "pred-123",
                    "status": "completed",
                    "outputs": ["https://media.example.com/logo.png"],
                },
            },
        ]

        logo_generate._generate_with_atlas(
            "logo prompt", "logo.png", "1:1", "atlas-key", "atlas/model"
        )

        self.assertEqual(json_request.call_count, 3)
        self.assertEqual(
            json_request.call_args_list[0],
            call(
                f"{logo_generate.ATLAS_API_BASE}/model/generateImage",
                "atlas-key",
                method="POST",
                payload={
                    "model": "atlas/model",
                    "prompt": "logo prompt",
                    "aspect_ratio": "1:1",
                },
            ),
        )
        self.assertEqual(
            json_request.call_args_list[1:],
            [
                call(
                    f"{logo_generate.ATLAS_API_BASE}/model/prediction/pred-123",
                    "atlas-key",
                ),
                call(
                    f"{logo_generate.ATLAS_API_BASE}/model/prediction/pred-123",
                    "atlas-key",
                ),
            ],
        )
        self.assertEqual(sleep.call_count, 2)
        download.assert_called_once_with(
            "https://media.example.com/logo.png", "logo.png"
        )

    @patch.object(logo_generate, "_json_request")
    def test_atlas_does_not_retry_generation_post(self, json_request):
        json_request.side_effect = RuntimeError("network error")

        with self.assertRaisesRegex(RuntimeError, "network error"):
            logo_generate._generate_with_atlas(
                "logo prompt", "logo.png", "1:1", "atlas-key", "atlas/model"
            )

        json_request.assert_called_once()

    @patch.object(logo_generate, "_validate_public_https_url")
    @patch.object(logo_generate, "build_opener")
    def test_media_download_never_forwards_api_key(self, build_opener, validate):
        class Headers:
            @staticmethod
            def get_content_type():
                return "image/png"

        class Response:
            headers = Headers()

            def __enter__(self):
                return self

            def __exit__(self, *args):
                return None

            @staticmethod
            def read():
                return b"png-bytes"

        build_opener.return_value.open.return_value = Response()

        with tempfile.TemporaryDirectory() as temp_dir:
            output = Path(temp_dir) / "logo.png"
            logo_generate._download_atlas_image(
                "https://media.example.com/logo.png", output
            )
            self.assertEqual(output.read_bytes(), b"png-bytes")

        request = build_opener.return_value.open.call_args.args[0]
        headers = {key.lower(): value for key, value in request.header_items()}
        self.assertNotIn("authorization", headers)
        self.assertEqual(headers["accept"], "image/*")
        self.assertEqual(headers["user-agent"], logo_generate.HTTP_USER_AGENT)
        validate.assert_called_once_with("https://media.example.com/logo.png")

    def test_atlas_requires_api_key(self):
        with self.assertRaisesRegex(RuntimeError, "ATLASCLOUD_API_KEY not set"):
            logo_generate._generate_with_atlas(
                "logo prompt", "logo.png", "1:1", None, "atlas/model"
            )

    def test_media_url_rejects_private_addresses(self):
        with self.assertRaisesRegex(ValueError, "non-public address"):
            logo_generate._validate_public_https_url("https://127.0.0.1/logo.png")

        with self.assertRaisesRegex(ValueError, "local hostname"):
            logo_generate._validate_public_https_url("https://assets.local/logo.png")


class MuapiGenerationTests(unittest.TestCase):
    @patch.object(logo_generate, "_download_muapi_image")
    @patch.object(logo_generate.time, "sleep")
    @patch.object(logo_generate, "_json_request")
    def test_muapi_submits_once_and_polls_until_completed(
        self, json_request, sleep, download
    ):
        json_request.side_effect = [
            {
                "id": "req-123",
                "status": "created",
                "output": {
                    "urls": {
                        "get": "https://api.muapi.ai/api/v1/results/req-123"
                    }
                },
            },
            {"id": "req-123", "status": "processing"},
            {
                "id": "req-123",
                "status": "completed",
                "output": {"outputs": ["https://media.example.com/logo.png"]},
            },
        ]

        logo_generate._generate_with_muapi(
            "logo prompt", "logo.png", "1:1", "muapi-key", "nano-banana"
        )

        self.assertEqual(json_request.call_count, 3)
        self.assertEqual(
            json_request.call_args_list[0],
            call(
                f"{logo_generate.MUAPI_API_BASE}/nano-banana",
                "muapi-key",
                method="POST",
                payload={"prompt": "logo prompt", "aspect_ratio": "1:1"},
                api_key_header="x-api-key",
            ),
        )
        self.assertEqual(
            json_request.call_args_list[1:],
            [
                call(
                    "https://api.muapi.ai/api/v1/results/req-123",
                    "muapi-key",
                    api_key_header="x-api-key",
                ),
                call(
                    "https://api.muapi.ai/api/v1/results/req-123",
                    "muapi-key",
                    api_key_header="x-api-key",
                ),
            ],
        )
        self.assertEqual(sleep.call_count, 2)
        download.assert_called_once_with(
            "https://media.example.com/logo.png", "logo.png"
        )

    @patch.object(logo_generate, "_json_request")
    def test_muapi_does_not_retry_generation_post(self, json_request):
        json_request.side_effect = RuntimeError("network error")

        with self.assertRaisesRegex(RuntimeError, "network error"):
            logo_generate._generate_with_muapi(
                "logo prompt", "logo.png", "1:1", "muapi-key", "nano-banana"
            )

        json_request.assert_called_once()

    def test_muapi_requires_key_and_known_model(self):
        with self.assertRaisesRegex(RuntimeError, "MUAPI_API_KEY not set"):
            logo_generate._generate_with_muapi(
                "logo prompt", "logo.png", "1:1", None, "nano-banana"
            )

        with self.assertRaisesRegex(RuntimeError, "Unsupported MuAPI logo model"):
            logo_generate._generate_with_muapi(
                "logo prompt", "logo.png", "1:1", "muapi-key", "unknown-model"
            )

    @patch.object(logo_generate, "build_opener")
    def test_muapi_uses_x_api_key_header(self, build_opener):
        class Response:
            def __enter__(self):
                return self

            def __exit__(self, *args):
                return None

            @staticmethod
            def read():
                return b"{}"

        build_opener.return_value.open.return_value = Response()

        logo_generate._json_request(
            "https://api.muapi.ai/api/v1/nano-banana",
            "muapi-key",
            method="POST",
            payload={"prompt": "logo"},
            api_key_header="x-api-key",
        )

        request = build_opener.return_value.open.call_args.args[0]
        headers = {key.lower(): value for key, value in request.header_items()}
        self.assertEqual(headers["x-api-key"], "muapi-key")
        self.assertNotIn("authorization", headers)

    @patch.object(logo_generate, "_json_request")
    def test_muapi_reports_failed_prediction(self, json_request):
        json_request.side_effect = [
            {
                "request_id": "req-123",
                "output": {
                    "urls": {
                        "get": "https://api.muapi.ai/api/v1/results/req-123"
                    }
                },
            },
            {"status": "failed", "error": "invalid prompt"},
        ]

        with self.assertRaisesRegex(RuntimeError, "invalid prompt"):
            logo_generate._generate_with_muapi(
                "logo prompt", "logo.png", "1:1", "muapi-key", "nano-banana"
            )

    @patch.object(logo_generate, "_json_request")
    def test_muapi_requires_creation_result_url(self, json_request):
        json_request.return_value = {"request_id": "req-123", "status": "created"}

        with self.assertRaisesRegex(RuntimeError, "valid HTTPS result URL"):
            logo_generate._generate_with_muapi(
                "logo prompt", "logo.png", "1:1", "muapi-key", "nano-banana"
            )

        json_request.assert_called_once()

    @patch.object(logo_generate, "_json_request")
    def test_muapi_rejects_invalid_creation_result_url(self, json_request):
        json_request.return_value = {
            "request_id": "req-123",
            "status": "created",
            "output": {"urls": {"get": "http://api.muapi.ai/results/req-123"}},
        }

        with self.assertRaisesRegex(RuntimeError, "valid HTTPS result URL"):
            logo_generate._generate_with_muapi(
                "logo prompt", "logo.png", "1:1", "muapi-key", "nano-banana"
            )

        json_request.assert_called_once()


class GeminiImageTypeTests(unittest.TestCase):
    def setUp(self):
        self.client = Mock()
        for patcher in (
            patch.dict(sys.modules, _fake_genai(self.client)),
            patch.object(logo_generate, "GEMINI_API_KEY", "test-key"),
        ):
            patcher.start()
            self.addCleanup(patcher.stop)
        temp_dir = tempfile.TemporaryDirectory()
        self.addCleanup(temp_dir.cleanup)
        self.dir = Path(temp_dir.name)

    def _generate(self, mime_type, data, requested_name):
        self.client.models.generate_content.return_value = _image_response(
            mime_type, data
        )
        return logo_generate._generate_with_gemini(
            "logo prompt", str(self.dir / requested_name), "1:1", use_pro=True
        )

    def test_jpeg_is_saved_with_jpg_extension(self):
        with patch("sys.stdout", new_callable=io.StringIO):
            saved = self._generate("image/jpeg", JPEG, "logo.png")

        self.assertEqual(saved, str(self.dir / "logo.jpg"))
        self.assertEqual(Path(saved).read_bytes(), JPEG)
        self.assertFalse((self.dir / "logo.png").exists())

    def test_matching_extension_keeps_requested_path(self):
        for mime_type, data, name in (
            ("image/png", PNG, "logo.png"),
            ("image/jpeg", JPEG, "logo.jpeg"),
            ("image/jpeg", JPEG, "logo.JPG"),
        ):
            with self.subTest(name=name):
                saved = self._generate(mime_type, data, name)
                self.assertEqual(saved, str(self.dir / name))
                self.assertEqual(Path(saved).read_bytes(), data)

    def test_unknown_image_type_keeps_requested_path(self):
        self.assertEqual(
            logo_generate._path_for_image_type("logo.png", "image/heic"), "logo.png"
        )

    def test_generate_logo_prints_and_returns_the_saved_path(self):
        self.client.models.generate_content.return_value = _image_response(
            "image/jpeg", JPEG
        )
        with patch("sys.stdout", new_callable=io.StringIO) as stdout:
            saved = logo_generate.generate_logo(
                "test mark", output_path=str(self.dir / "logo.png"), use_pro=True
            )

        self.assertEqual(saved, str(self.dir / "logo.jpg"))
        self.assertIn(f"Logo saved to: {saved}", stdout.getvalue())

    def test_pro_requests_the_configured_pro_model(self):
        self._generate("image/png", PNG, "logo.png")

        self.assertEqual(
            self.client.models.generate_content.call_args.kwargs["model"],
            logo_generate.GEMINI_PRO,
        )


class GeminiModelIdTests(unittest.TestCase):
    def test_pro_defaults_to_the_ga_model(self):
        with patch.dict(os.environ):
            os.environ.pop("GEMINI_PRO_IMAGE_MODEL", None)
            module = _load_module()

        self.assertEqual(module.GEMINI_PRO, "gemini-3-pro-image")

    def test_model_ids_can_be_overridden_from_the_environment(self):
        with patch.dict(
            os.environ,
            {"GEMINI_FLASH_IMAGE_MODEL": "flash-next", "GEMINI_PRO_IMAGE_MODEL": "pro-next"},
        ):
            module = _load_module()

        self.assertEqual(module.GEMINI_FLASH, "flash-next")
        self.assertEqual(module.GEMINI_PRO, "pro-next")


class ExitStatusTests(unittest.TestCase):
    def setUp(self):
        temp_dir = tempfile.TemporaryDirectory()
        self.addCleanup(temp_dir.cleanup)
        self.dir = Path(temp_dir.name)

    def _run_main(self, *args):
        with patch.object(sys, "argv", ["generate.py", *args]), patch(
            "sys.stdout", new_callable=io.StringIO
        ):
            logo_generate.main()

    def test_failed_single_request_exits_1(self):
        client = Mock()
        client.models.generate_content.side_effect = RuntimeError(
            "429 RESOURCE_EXHAUSTED"
        )
        with patch.dict(sys.modules, _fake_genai(client)), patch.object(
            logo_generate, "GEMINI_API_KEY", "test-key"
        ), self.assertRaises(SystemExit) as raised:
            self._run_main("--prompt", "test mark", "--output", str(self.dir / "logo.png"))

        self.assertEqual(raised.exception.code, 1)

    @patch.object(logo_generate.time, "sleep")
    @patch.object(logo_generate, "generate_logo", return_value=None)
    def test_batch_with_no_logos_exits_1(self, generate_logo, sleep):
        with self.assertRaises(SystemExit) as raised:
            self._run_main(
                "--brand", "Demo", "--batch", "2", "--output-dir", str(self.dir)
            )

        self.assertEqual(raised.exception.code, 1)
        self.assertEqual(generate_logo.call_count, 2)

    @patch.object(logo_generate.time, "sleep")
    @patch.object(
        logo_generate, "generate_logo", side_effect=[None, "demo_modern_02.png"]
    )
    def test_partial_batch_exits_0(self, generate_logo, sleep):
        self._run_main("--brand", "Demo", "--batch", "2", "--output-dir", str(self.dir))

        self.assertEqual(generate_logo.call_count, 2)

    def test_list_styles_exits_0(self):
        self._run_main("--list-styles")


if __name__ == "__main__":
    unittest.main()
canvas-designanthropics/skillsCreate beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
docxanthropics/skillsUse this skill whenever the user wants to create, read, edit, or manipulate Word documents (.docx files) or Word templates (.dotx files). Triggers include: any mention of 'Word doc', 'word document', '.docx', '.dotx', or requests to produce professional documents with formatting like tables of contents, headings, page numbers, or letterheads. Also use when extracting or reorganizing content from .docx or .dotx files, inserting or replacing images in documents, performing find-and-replace in Word files, working with tracked changes or comments, or converting content into a polished Word document. If the user asks for a 'report', 'memo', 'letter', 'template', or similar deliverable as a Word or .docx file, use this skill. Do NOT use for PDFs, spreadsheets, Google Docs, or general coding tasks unrelated to document generation.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
pdfanthropics/skillsUse this skill whenever the user wants to do anything with PDF files. This includes reading or extracting text/tables from PDFs, combining or merging multiple PDFs into one, splitting PDFs apart, rotating pages, adding watermarks, creating new PDFs, filling PDF forms, encrypting/decrypting PDFs, extracting images, and OCR on scanned PDFs to make them searchable. If the user mentions a .pdf file or asks to produce one, use this skill.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
pptxanthropics/skillsUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an email or summary); editing, modifying, or updating existing presentations; combining or splitting slide files; working with templates (.potx), layouts, speaker notes, or comments. Trigger whenever the user mentions "deck," "slides," "presentation," or references a .pptx or .potx filename, regardless of what they plan to do with the content afterward. If a .pptx or .potx file needs to be opened, created, or touched, use this skill.Stars: 196kUpdated Claude CodeCodexVerifiedInstall