blammectrappora

---
name: pet-renaissance-portrait-generator
description: your pet into a royal Renaissance masterpiece — AI-powered royal pet portrait generator creates museum-quality oil painting portraits of dogs, cats, and any pet as 17th-century aristocrats, medieval knights, or baroque nobility. Perfect for pet lovers, custom pet art, viral social media content, unique gift ideas, and personalized wall art via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Pet Renaissance Portrait Generator

your pet into a royal Renaissance masterpiece — AI-powered royal pet portrait generator creates museum-quality oil painting portraits of dogs, cats, and any pet as 17th-century aristocrats, medieval knights, or baroque nobility. Perfect for pet lovers, custom pet art, viral social media content, unique gift ideas, and personalized wall art.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create royal pet portrait ai generator images.

## Quick start
```bash
node petrenaissanceportraitgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/pet-renaissance-portrait-generator
```

FILE:README.md
# Pet Renaissance Portrait Generator

Generate stunning royal Renaissance oil painting portraits of any pet from text descriptions. Describe your dog, cat, rabbit, or any pet, and receive a museum-quality baroque masterpiece depicting them as 17th-century aristocrats, medieval knights, or baroque nobility — complete with velvet robes, ornate gold jewelry, and dramatic Rembrandt lighting.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/pet-renaissance-portrait-generator
```

**Via ClawHub:**
```bash
clawhub install pet-renaissance-portrait-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node petrenaissanceportraitgenerator.js "<prompt>" --token YOUR_TOKEN [--size <size>] [--ref <uuid>]
```

### Examples

Generate a portrait of a golden retriever as a Renaissance nobleman:
```bash
node petrenaissanceportraitgenerator.js \
  "a majestic golden retriever dressed in elaborate 17th-century aristocratic clothing, velvet robes, ornate gold jewelry, regal pose, dramatic Rembrandt lighting, baroque oil painting style" \
  --token "$NETA_TOKEN"
```

Generate a landscape-format portrait of a Persian cat as a royal duchess:
```bash
node petrenaissanceportraitgenerator.js \
  "a regal Persian cat in the style of a baroque duchess portrait, wearing an ornate lace collar and pearl necklace, rich jewel-toned background, old master painting" \
  --token "$NETA_TOKEN" \
  --size landscape
```

Use a reference image UUID for style inheritance:
```bash
node petrenaissanceportraitgenerator.js \
  "a noble beagle in a 17th-century military uniform, dramatic lighting, Renaissance oil painting" \
  --token "$NETA_TOKEN" \
  --ref "some-picture-uuid-here"
```

### Output

Returns a direct image URL printed to stdout. Redirect or pipe it as needed:

```bash
IMAGE_URL=$(node petrenaissanceportraitgenerator.js "a majestic tabby cat in velvet robes" --token "$NETA_TOKEN")
echo "$IMAGE_URL"
```

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | *(required)* | Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--ref` | UUID string | *(none)* | Reference image UUID for style inheritance |

### Size Dimensions

| Size | Width | Height |
|------|-------|--------|
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `square` | 1024 | 1024 |
| `tall` | 704 | 1408 |

---

## Default Prompt

If you want a ready-made starting point, try this default prompt (replace `[pet breed]` with your pet's breed):

```
a majestic Renaissance oil painting portrait of a [pet breed], dressed in elaborate 17th-century aristocratic clothing, velvet robes, ornate gold jewelry and collar, regal dignified pose, dramatic Rembrandt lighting, rich jewel-toned background, museum-quality baroque masterpiece, highly detailed brushwork, old master painting style
```

---

## How It Works

1. Your text description is sent to the Neta AI image generation API.
2. The API queues a generation job and returns a task UUID.
3. The script polls for completion every 2 seconds (up to 90 attempts / ~3 minutes).
4. When the image is ready, the direct image URL is printed to stdout.


FILE:package.json
{"name":"pet-renaissance-portrait-generator","version":"1.0.0","type":"module","description":"Pet Renaissance Portrait Generator — AI-powered royal pet portrait ai generator","license":"MIT"}

FILE:petrenaissanceportraitgenerator.js
#!/usr/bin/env node
// Pet Renaissance Portrait Generator
// Generates royal Renaissance oil painting portraits of pets via the Neta AI image generation API.

const args = process.argv.slice(2);

// Parse CLI arguments
let prompt = null;
let size = 'portrait';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  console.error('\n✗ Prompt required as the first positional argument.');
  console.error('  Example: node petrenaissanceportraitgenerator.js "a majestic golden retriever in velvet robes" --token YOUR_TOKEN');
  process.exit(1);
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const dimensions = SIZES[size] || SIZES.portrait;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

async function makeImage() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width: dimensions.width,
    height: dimensions.height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    body.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    console.error(`✗ Failed to start image generation (HTTP res.status): text`);
    process.exit(1);
  }

  const data = await res.json();
  const taskUuid = typeof data === 'string' ? data : data.task_uuid;

  if (!taskUuid) {
    console.error('✗ No task_uuid returned from API.');
    console.error(JSON.stringify(data, null, 2));
    process.exit(1);
  }

  console.error(`Generating image... (task: taskUuid)`);
  return taskUuid;
}

async function pollTask(taskUuid) {
  const maxAttempts = 90;
  const delayMs = 2000;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    await new Promise(resolve => setTimeout(resolve, delayMs));

    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: HEADERS,
    });

    if (!res.ok) {
      const text = await res.text();
      console.error(`✗ Poll request failed (HTTP res.status): text`);
      process.exit(1);
    }

    const data = await res.json();
    const status = data.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      process.stderr.write('.');
      continue;
    }

    // Done — extract image URL
    process.stderr.write('\n');
    const url =
      (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;

    if (!url) {
      console.error('✗ No image URL found in response.');
      console.error(JSON.stringify(data, null, 2));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error('\n✗ Timed out waiting for image generation.');
  process.exit(1);
}

const taskUuid = await makeImage();
await pollTask(taskUuid);

---
name: miniature-world-generator
description: AI miniature world and diorama art generator — create tilt-shift miniature scenes, tiny world illustrations, hyper-detailed diorama art, and shallow-depth-of-field fantasy landscapes. Perfect for Instagram art, Pinterest boards, desktop wallpapers, and creative visual storytelling via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Miniature World Generator

AI miniature world and diorama art generator — create tilt-shift miniature scenes, tiny world illustrations, hyper-detailed diorama art, and shallow-depth-of-field fantasy landscapes. Perfect for Instagram art, Pinterest boards, desktop wallpapers, and creative visual storytelling.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create miniature world diorama art generator images.

## Quick start
```bash
node miniatureworldgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `square`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/miniature-world-generator
```

FILE:README.md
# Miniature World Generator

Generate hyper-detailed miniature diorama scenes and tiny world art from text descriptions. Describe any scene — a bustling city block scaled down to a tabletop, a magical forest in a teacup, a snow-globe winter village — and receive a stunning tilt-shift image with shallow depth of field and whimsical atmosphere.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

```bash
# via npx skills
npx skills add blammectrappora/miniature-world-generator

# via clawhub
clawhub install miniature-world-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node miniatureworldgenerator.js "<description>" --token YOUR_TOKEN [--size <size>] [--ref <uuid>]
```

If no prompt is provided, a default diorama prompt is used automatically.

### Examples

```bash
# Tiny Japanese street market at night
node miniatureworldgenerator.js "tiny Japanese street market at night, paper lanterns, miniature stalls, tilt-shift, bokeh" --token "$NETA_TOKEN"

# Autumn forest diorama
node miniatureworldgenerator.js "miniature autumn forest with tiny log cabin, fallen leaves, misty morning light, bird's eye view" --token "$NETA_TOKEN" --size portrait

# Landscape format beach scene
node miniatureworldgenerator.js "hyper-detailed miniature tropical beach, tiny palm trees, crystal clear water, aerial view" --token "$NETA_TOKEN" --size landscape

# Using a reference image for style inheritance
node miniatureworldgenerator.js "snowy alpine village diorama" --token "$NETA_TOKEN" --ref xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

### Output

Returns a direct image URL printed to stdout.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | *(required)* | Your Neta API token |
| `--size` | `square`, `portrait`, `landscape`, `tall` | `square` | Output image dimensions |
| `--ref` | UUID string | *(none)* | Reference image UUID for style inheritance |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `square` | 1024 | 1024 |
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `tall` | 704 | 1408 |

---

## Tips for great prompts

- Mention **tilt-shift**, **shallow depth of field**, or **bokeh** for the classic miniature look
- Include **bird's eye view** or **aerial perspective** for a diorama feel
- Describe **scale cues**: tiny, miniature, tabletop, diorama, figurines
- Add a **mood**: whimsical, magical, cozy, dramatic, cinematic

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:miniatureworldgenerator.js
#!/usr/bin/env node
const args = process.argv.slice(2);

// Parse CLI arguments
let prompt = null;
let size = 'square';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'hyper-detailed miniature diorama scene, tilt-shift photography effect, shallow depth of field, tiny world perspective, vivid colors, highly detailed figurines and props, bokeh background blur, bird\'s eye view, whimsical and magical atmosphere';
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const { width, height } = SIZES[size] || SIZES.square;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

async function makeImage() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width,
    height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    body.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    console.error(`✗ Failed to start generation (res.status): text`);
    process.exit(1);
  }

  const data = await res.json();
  const taskUuid = typeof data === 'string' ? data : data.task_uuid;

  if (!taskUuid) {
    console.error('✗ No task_uuid in response:', JSON.stringify(data));
    process.exit(1);
  }

  return taskUuid;
}

async function pollTask(taskUuid) {
  const maxAttempts = 90;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    await new Promise(r => setTimeout(r, 2000));

    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: HEADERS,
    });

    if (!res.ok) {
      const text = await res.text();
      console.error(`✗ Poll failed (res.status): text`);
      process.exit(1);
    }

    const data = await res.json();
    const status = data.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      continue;
    }

    // Done — extract URL
    const url =
      (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;

    if (!url) {
      console.error('✗ Generation finished but no image URL found:', JSON.stringify(data));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error('✗ Timed out waiting for image generation.');
  process.exit(1);
}

const taskUuid = await makeImage();
await pollTask(taskUuid);

FILE:package.json
{"name":"miniature-world-generator","version":"1.0.0","type":"module","description":"Miniature World Generator — AI-powered miniature world diorama art generator ai","license":"MIT"}

---
name: comic-panel-generator
description: Generate AI comic book panels, manga strips, and graphic novel art from text descriptions. Create anime-style comic illustrations, webcomic frames, storyboard panels, manga-style sequential art, and comic character scenes with dynamic compositions and bold ink outlines via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Comic Panel Generator

Generate AI comic book panels, manga strips, and graphic novel art from text descriptions. Create anime-style comic illustrations, webcomic frames, storyboard panels, manga-style sequential art, and comic character scenes with dynamic compositions and bold ink outlines.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create ai comic panel generator images.

## Quick start
```bash
node comicpanelgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/comic-panel-generator
```

FILE:README.md
# Comic Panel Generator

Generate AI comic book panels, manga strips, and graphic novel art from text descriptions. Describe a scene, character, or moment and receive a fully rendered comic illustration with bold ink outlines, dynamic compositions, and anime-style cel shading.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/comic-panel-generator
```

**Via ClawHub:**
```bash
clawhub install comic-panel-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node comicpanelgenerator.js "PROMPT" --token YOUR_TOKEN [--size SIZE] [--ref UUID]
```

### Examples

```bash
# Portrait manga panel (default)
node comicpanelgenerator.js "a samurai standing on a rooftop at night, rain falling, dramatic lighting" --token "$NETA_TOKEN"

# Landscape action scene
node comicpanelgenerator.js "two heroes facing off in a neon-lit city alley, dynamic angles, bold outlines" --token "$NETA_TOKEN" --size landscape

# Tall vertical panel
node comicpanelgenerator.js "a wizard casting a spell, magical energy swirling, manga style" --token "$NETA_TOKEN" --size tall

# Square panel with style reference
node comicpanelgenerator.js "cyberpunk street scene, futuristic fashion" --token "$NETA_TOKEN" --size square --ref SOME_UUID
```

### Output

Returns a direct image URL.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | — | **Required.** Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--ref` | UUID string | — | Reference image UUID for style inheritance |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `square` | 1024 | 1024 |
| `tall` | 704 | 1408 |

---

## Default Prompt

If no prompt is provided, the following default is used:

> comic book panel illustration, bold ink outlines, dynamic composition, manga style, expressive characters, cel shading, dramatic lighting, professional comic art, sequential storytelling panel

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:comicpanelgenerator.js
#!/usr/bin/env node
import https from "https";

const args = process.argv.slice(2);

let prompt = null;
let size = "portrait";
let tokenFlag = null;
let refUUID = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--size" && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === "--token" && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === "--ref" && args[i + 1]) {
    refUUID = args[++i];
  } else if (!args[i].startsWith("--") && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error("\n✗ Token required. Pass via: --token YOUR_TOKEN");
  console.error("  Get yours at: https://www.neta.art/open/");
  process.exit(1);
}

if (!prompt) {
  prompt =
    "comic book panel illustration, bold ink outlines, dynamic composition, manga style, expressive characters, cel shading, dramatic lighting, professional comic art, sequential storytelling panel";
}

const sizes = {
  square: { width: 1024, height: 1024 },
  portrait: { width: 832, height: 1216 },
  landscape: { width: 1216, height: 832 },
  tall: { width: 704, height: 1408 },
};

const { width, height } = sizes[size] || sizes.portrait;

const HEADERS = {
  "x-token": TOKEN,
  "x-platform": "nieta-app/web",
  "content-type": "application/json",
};

function request(method, urlStr, body) {
  return new Promise((resolve, reject) => {
    const url = new URL(urlStr);
    const options = {
      hostname: url.hostname,
      path: url.pathname + url.search,
      method,
      headers: HEADERS,
    };
    const req = https.request(options, (res) => {
      let data = "";
      res.on("data", (chunk) => (data += chunk));
      res.on("end", () => {
        try {
          resolve(JSON.parse(data));
        } catch {
          resolve(data.trim());
        }
      });
    });
    req.on("error", reject);
    if (body) req.write(JSON.stringify(body));
    req.end();
  });
}

function sleep(ms) {
  return new Promise((r) => setTimeout(r, ms));
}

async function main() {
  const makeBody = {
    storyId: "DO_NOT_USE",
    jobType: "universal",
    rawPrompt: [{ type: "freetext", value: prompt, weight: 1 }],
    width,
    height,
    meta: { entrance: "PICTURE,VERSE" },
    context_model_series: "8_image_edit",
  };

  if (refUUID) {
    makeBody.inherit_params = {
      collection_uuid: refUUID,
      picture_uuid: refUUID,
    };
  }

  let makeRes;
  try {
    makeRes = await request(
      "POST",
      "https://api.talesofai.com/v3/make_image",
      makeBody
    );
  } catch (err) {
    console.error("✗ Failed to submit job:", err.message);
    process.exit(1);
  }

  const taskUUID =
    typeof makeRes === "string"
      ? makeRes
      : makeRes.task_uuid || makeRes.taskUUID;

  if (!taskUUID) {
    console.error("✗ No task_uuid in response:", JSON.stringify(makeRes));
    process.exit(1);
  }

  console.error(`Generating... (task: taskUUID)`);

  const pollURL = `https://api.talesofai.com/v1/artifact/task/taskUUID`;
  const MAX_ATTEMPTS = 90;

  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
    await sleep(2000);
    let pollRes;
    try {
      pollRes = await request("GET", pollURL, null);
    } catch (err) {
      console.error("✗ Poll error:", err.message);
      process.exit(1);
    }

    const status = pollRes.task_status;
    if (status === "PENDING" || status === "MODERATION") {
      continue;
    }

    const url =
      pollRes.artifacts?.[0]?.url || pollRes.result_image_url;

    if (!url) {
      console.error("✗ No image URL in response:", JSON.stringify(pollRes));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error("✗ Timed out waiting for image generation.");
  process.exit(1);
}

main();

FILE:package.json
{"name":"comic-panel-generator","version":"1.0.0","type":"module","description":"Comic Panel Generator — AI-powered ai comic panel generator","license":"MIT"}

---
name: watercolor-art-generator
description: AI watercolor art generator — create stunning watercolor paintings, portraits, and illustrations instantly. Perfect for watercolor portrait commissions, digital watercolor artwork, custom watercolor gifts, social media art, and printable wall art. Also great as a watercolor painting maker, aquarelle portrait creator, and watercolor illustration generator via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Watercolor Art Generator

AI watercolor art generator — create stunning watercolor paintings, portraits, and illustrations instantly. Perfect for watercolor portrait commissions, digital watercolor artwork, custom watercolor gifts, social media art, and printable wall art. Also great as a watercolor painting maker, aquarelle portrait creator, and watercolor illustration generator.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create watercolor art generator images.

## Quick start
```bash
node watercolorartgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/watercolor-art-generator
```

FILE:README.md
# Watercolor Art Generator

Generate stunning watercolor paintings, portraits, and illustrations from text descriptions — instantly, using AI. Describe any scene, subject, or style and receive a high-quality watercolor artwork ready for printing, sharing, or gifting.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/watercolor-art-generator
```

**Via ClawHub:**
```bash
clawhub install watercolor-art-generator
```

---

## Usage

```bash
node watercolorartgenerator.js "your description here" --token YOUR_TOKEN
```

### Examples

```bash
# Portrait of a woman with soft watercolor washes
node watercolorartgenerator.js "portrait of a woman, soft translucent watercolor washes, luminous pastel hues" --token "$NETA_TOKEN"

# Landscape in watercolor
node watercolorartgenerator.js "misty mountain landscape, wet-on-wet watercolor blending, delicate brushstrokes" --token "$NETA_TOKEN" --size landscape

# Square watercolor illustration
node watercolorartgenerator.js "botanical floral arrangement, fine art watercolor illustration style" --token "$NETA_TOKEN" --size square

# Tall format with style reference
node watercolorartgenerator.js "fairy tale castle at dusk, watercolor painting" --token "$NETA_TOKEN" --size tall --ref abc123-uuid
```

**Output:** Returns a direct image URL.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | *(required)* | Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--ref` | UUID string | *(none)* | Reference image UUID for style inheritance |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `square` | 1024 | 1024 |
| `tall` | 704 | 1408 |

---

## Token Setup

This skill requires a Neta API token. Pass it using the `--token` flag:

```bash
node watercolorartgenerator.js "your prompt" --token YOUR_TOKEN
```

You can store your token in a shell variable and expand it:

```bash
export NETA_TOKEN="your_token_here"
node watercolorartgenerator.js "your prompt" --token "$NETA_TOKEN"
```

Get your free token at: https://www.neta.art/open/


FILE:package.json
{"name":"watercolor-art-generator","version":"1.0.0","type":"module","description":"Watercolor Art Generator — AI-powered watercolor art generator ai","license":"MIT"}

FILE:watercolorartgenerator.js
#!/usr/bin/env node
import https from 'https';

const args = process.argv.slice(2);

let prompt = null;
let size = 'portrait';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'a beautiful watercolor painting portrait, soft translucent washes of color, visible paper texture, wet-on-wet blending, delicate brushstrokes, luminous pastel hues, fine art watercolor illustration style';
}

const sizes = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const { width, height } = sizes[size] || sizes.portrait;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

function request(method, url, body) {
  return new Promise((resolve, reject) => {
    const parsed = new URL(url);
    const options = {
      hostname: parsed.hostname,
      path: parsed.pathname + parsed.search,
      method,
      headers: { ...HEADERS },
    };

    let bodyStr;
    if (body) {
      bodyStr = JSON.stringify(body);
      options.headers['content-length'] = Buffer.byteLength(bodyStr);
    }

    const req = https.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => { data += chunk; });
      res.on('end', () => {
        try {
          resolve(JSON.parse(data));
        } catch {
          resolve(data.trim());
        }
      });
    });

    req.on('error', reject);
    if (bodyStr) req.write(bodyStr);
    req.end();
  });
}

function sleep(ms) {
  return new Promise((r) => setTimeout(r, ms));
}

async function main() {
  const makeBody = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width,
    height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    makeBody.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  const makeRes = await request('POST', 'https://api.talesofai.com/v3/make_image', makeBody);

  const taskUuid = typeof makeRes === 'string' ? makeRes : makeRes.task_uuid;
  if (!taskUuid) {
    console.error('✗ Failed to get task_uuid from API response:', JSON.stringify(makeRes));
    process.exit(1);
  }

  const pollUrl = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  const maxAttempts = 90;

  for (let i = 0; i < maxAttempts; i++) {
    await sleep(2000);
    const pollRes = await request('GET', pollUrl);
    const status = pollRes.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      continue;
    }

    const url =
      (pollRes.artifacts && pollRes.artifacts[0] && pollRes.artifacts[0].url) ||
      pollRes.result_image_url;

    if (url) {
      console.log(url);
      process.exit(0);
    } else {
      console.error('✗ Task finished but no image URL found:', JSON.stringify(pollRes));
      process.exit(1);
    }
  }

  console.error('✗ Timed out waiting for image generation.');
  process.exit(1);
}

main().catch((err) => {
  console.error('✗ Unexpected error:', err.message);
  process.exit(1);
});

---
name: steampunk-art-generator
description: AI steampunk art generator — create Victorian steampunk portraits, cyberpunk Victorian characters, brass-and-gears illustrations, cosplay reference art, and industrial fantasy scenes. Perfect for steampunk fans, cosplayers, worldbuilders, and retro-futuristic art lovers via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Steampunk Art Generator

AI steampunk art generator — create Victorian steampunk portraits, cyberpunk Victorian characters, brass-and-gears illustrations, cosplay reference art, and industrial fantasy scenes. Perfect for steampunk fans, cosplayers, worldbuilders, and retro-futuristic art lovers.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create steampunk art generator images.

## Quick start
```bash
node steampunkartgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/steampunk-art-generator
```

FILE:README.md
# Steampunk Art Generator

Generate stunning steampunk artwork from text descriptions — Victorian portraits with brass gears, clockwork machinery, ornate goggles, leather-and-copper aesthetics, and industrial fantasy scenes. Describe your vision and receive a high-quality AI-generated image in seconds.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/steampunk-art-generator
```

**Via ClawHub:**
```bash
clawhub install steampunk-art-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage Examples

**Default steampunk portrait:**
```bash
node steampunkartgenerator.js "steampunk inventor with clockwork arm" --token "$NETA_TOKEN"
```

**Landscape scene:**
```bash
node steampunkartgenerator.js "steampunk city skyline with airships and factory smokestacks" --token "$NETA_TOKEN" --size landscape
```

**Tall portrait format:**
```bash
node steampunkartgenerator.js "Victorian lady with ornate brass goggles and corset, steampunk fashion" --token "$NETA_TOKEN" --size tall
```

**Square format:**
```bash
node steampunkartgenerator.js "steampunk clockwork cat, mechanical gears, copper and bronze" --token "$NETA_TOKEN" --size square
```

**With style reference:**
```bash
node steampunkartgenerator.js "steampunk knight in full brass armor" --token "$NETA_TOKEN" --ref <picture_uuid>
```

**Output:** Returns a direct image URL.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | *(required)* | Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--ref` | UUID string | *(none)* | Reference image UUID for style inheritance |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `square` | 1024 | 1024 |
| `tall` | 704 | 1408 |

---

## Prompt Tips

- Be descriptive: include materials (brass, copper, leather), lighting (gaslight, candlelight), and mood (dramatic, mysterious)
- Mention specific steampunk elements: clockwork gears, steam engines, airships, top hats, goggles, mechanical limbs
- Add era details: Victorian, Edwardian, industrial revolution
- Include artistic style cues: cinematic, illustration, oil painting, concept art

**Example prompts:**
- `"steampunk explorer, pith helmet with brass compass, leather coat covered in pockets and gadgets, dramatic lighting"`
- `"steampunk laboratory interior, bubbling alchemical apparatus, copper pipes and gauges, warm amber gaslight"`
- `"Victorian steampunk duchess, elaborate clockwork jewelry, silk and gears, aristocratic setting"`


FILE:package.json
{"name":"steampunk-art-generator","version":"1.0.0","type":"module","description":"Steampunk Art Generator — AI-powered steampunk art generator ai","license":"MIT"}

FILE:steampunkartgenerator.js
#!/usr/bin/env node
// Steampunk Art Generator — powered by Neta AI (api.talesofai.com)

const args = process.argv.slice(2);

// Parse CLI arguments
let prompt = null;
let size = 'portrait';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'steampunk portrait, Victorian era brass gears and clockwork machinery, leather and copper aesthetic, ornate goggles, steam-powered devices, industrial fantasy, dramatic gaslight lighting, detailed mechanical embellishments, rich warm tones';
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const dims = SIZES[size] ?? SIZES.portrait;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

async function makeImage() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width: dims.width,
    height: dims.height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    body.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    console.error(`✗ Image request failed (res.status): text`);
    process.exit(1);
  }

  const data = await res.json();
  const taskUuid = typeof data === 'string' ? data : data.task_uuid;

  if (!taskUuid) {
    console.error('✗ No task_uuid in response:', JSON.stringify(data));
    process.exit(1);
  }

  console.error(`Generating image (task: taskUuid)...`);

  // Poll for result
  const MAX_ATTEMPTS = 90;
  const POLL_INTERVAL_MS = 2000;

  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
    await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));

    const pollRes = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: HEADERS,
    });

    if (!pollRes.ok) {
      console.error(`✗ Poll failed (pollRes.status)`);
      process.exit(1);
    }

    const result = await pollRes.json();
    const status = result.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      process.stderr.write('.');
      continue;
    }

    // Done
    process.stderr.write('\n');
    const url =
      result.artifacts?.[0]?.url ??
      result.result_image_url;

    if (!url) {
      console.error('✗ No image URL in result:', JSON.stringify(result));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error('\n✗ Timed out waiting for image generation.');
  process.exit(1);
}

makeImage().catch(err => {
  console.error('✗ Unexpected error:', err.message);
  process.exit(1);
});

---
name: kawaii-art-generator
description: AI kawaii art generator — create cute kawaii characters, chibi-style illustrations, and adorable Japanese kawaii artwork with soft pastel colors, big sparkling eyes, and dreamy aesthetics. Perfect for kawaii profile pictures, cute stickers, chibi OC designs, and kawaii wallpapers via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Kawaii Art Generator

AI kawaii art generator — create cute kawaii characters, chibi-style illustrations, and adorable Japanese kawaii artwork with soft pastel colors, big sparkling eyes, and dreamy aesthetics. Perfect for kawaii profile pictures, cute stickers, chibi OC designs, and kawaii wallpapers.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create kawaii art generator images.

## Quick start
```bash
node kawaiiartgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `square`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/kawaii-art-generator
```

FILE:README.md
# Kawaii Art Generator

Generate adorable kawaii artwork from text descriptions — cute chibi characters, soft pastel illustrations, Japanese kawaii aesthetics, and dreamy scenes, all produced via AI image generation.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

## Install

```bash
npx skills add blammectrappora/kawaii-art-generator
```

```bash
clawhub install kawaii-art-generator
```

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node kawaiiartgenerator.js "PROMPT" --token YOUR_TOKEN [--size SIZE] [--ref UUID]
```

### Examples

```bash
# Default kawaii style
node kawaiiartgenerator.js "kawaii cat girl with pastel pink hair and star accessories" --token "$NETA_TOKEN"

# Chibi character portrait
node kawaiiartgenerator.js "chibi magical girl, sparkling eyes, fluffy dress, pastel rainbow background" --token "$NETA_TOKEN" --size portrait

# Kawaii food illustration
node kawaiiartgenerator.js "cute kawaii strawberry cake character, big shiny eyes, rosy cheeks, soft watercolor style" --token "$NETA_TOKEN" --size square

# Landscape scene
node kawaiiartgenerator.js "dreamy kawaii forest with adorable animal characters, soft pastel colors, sparkles" --token "$NETA_TOKEN" --size landscape

# Tall format for wallpaper
node kawaiiartgenerator.js "kawaii anime girl under sakura tree, soft pink palette, chibi proportions" --token "$NETA_TOKEN" --size tall
```

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | — | Neta API token (required) |
| `--size` | `square`, `portrait`, `landscape`, `tall` | `square` | Output image dimensions |
| `--ref` | UUID string | — | Reference image UUID for style inheritance |

### Size Dimensions

| Size | Dimensions |
|------|------------|
| `square` | 1024 × 1024 |
| `portrait` | 832 × 1216 |
| `landscape` | 1216 × 832 |
| `tall` | 704 × 1408 |

## Output

Returns a direct image URL printed to stdout. Redirect or capture it as needed:

```bash
URL=$(node kawaiiartgenerator.js "kawaii bunny girl" --token "$NETA_TOKEN")
echo "$URL"
```

## Default Prompt

If no prompt is provided, the script uses a built-in kawaii default:

> kawaii style illustration, soft pastel color palette, large sparkling eyes, chibi proportions, rosy cheeks, fluffy and round forms, adorable accessories, Japanese kawaii aesthetic, clean linework, dreamy background

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:kawaiiartgenerator.js
#!/usr/bin/env node
import https from 'https';

const args = process.argv.slice(2);

let prompt = null;
let size = 'square';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'kawaii style illustration, soft pastel color palette, large sparkling eyes, chibi proportions, rosy cheeks, fluffy and round forms, adorable accessories, Japanese kawaii aesthetic, clean linework, dreamy background';
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const { width, height } = SIZES[size] || SIZES.square;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

function request(method, url, body) {
  return new Promise((resolve, reject) => {
    const parsed = new URL(url);
    const options = {
      hostname: parsed.hostname,
      path: parsed.pathname + parsed.search,
      method,
      headers: { ...HEADERS },
    };
    const payload = body ? JSON.stringify(body) : null;
    if (payload) {
      options.headers['content-length'] = Buffer.byteLength(payload);
    }
    const req = https.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => { data += chunk; });
      res.on('end', () => {
        try {
          resolve(JSON.parse(data));
        } catch {
          resolve(data.trim());
        }
      });
    });
    req.on('error', reject);
    if (payload) req.write(payload);
    req.end();
  });
}

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function main() {
  const makeBody = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width,
    height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    makeBody.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  console.error('Generating kawaii art...');
  const makeRes = await request('POST', 'https://api.talesofai.com/v3/make_image', makeBody);

  let taskUuid;
  if (typeof makeRes === 'string') {
    taskUuid = makeRes;
  } else if (makeRes && makeRes.task_uuid) {
    taskUuid = makeRes.task_uuid;
  } else {
    console.error('✗ Unexpected response from make_image:', JSON.stringify(makeRes));
    process.exit(1);
  }

  console.error(`Task: taskUuid`);

  const maxAttempts = 90;
  for (let i = 0; i < maxAttempts; i++) {
    await sleep(2000);
    const pollRes = await request('GET', `https://api.talesofai.com/v1/artifact/task/taskUuid`, null);

    const status = pollRes && pollRes.task_status;
    if (status === 'PENDING' || status === 'MODERATION') {
      process.stderr.write('.');
      continue;
    }

    process.stderr.write('\n');

    if (pollRes && pollRes.artifacts && pollRes.artifacts[0] && pollRes.artifacts[0].url) {
      console.log(pollRes.artifacts[0].url);
      process.exit(0);
    } else if (pollRes && pollRes.result_image_url) {
      console.log(pollRes.result_image_url);
      process.exit(0);
    } else {
      console.error('✗ No image URL in response:', JSON.stringify(pollRes));
      process.exit(1);
    }
  }

  console.error('\n✗ Timed out waiting for image generation.');
  process.exit(1);
}

main().catch((err) => {
  console.error('✗ Error:', err.message || err);
  process.exit(1);
});

FILE:package.json
{"name":"kawaii-art-generator","version":"1.0.0","type":"module","description":"Kawaii Art Generator — AI-powered kawaii art generator ai","license":"MIT"}

---
name: polaroid-photo-generator
description: AI polaroid photo generator — create retro instant-film photos with authentic vintage color, film grain, and '70s–'80s aesthetic. Perfect for nostalgic portraits, travel snapshots, lifestyle content, retro photo art, and old-school photography effects via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Polaroid Photo Generator

AI polaroid photo generator — create retro instant-film photos with authentic vintage color, film grain, and '70s–'80s aesthetic. Perfect for nostalgic portraits, travel snapshots, lifestyle content, retro photo art, and old-school photography effects.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create polaroid photo generator images.

## Quick start
```bash
node polaroidphotogenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `square`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/polaroid-photo-generator
```

FILE:README.md
# Polaroid Photo Generator

Generate stunning retro polaroid-style photos from text descriptions using AI. Describe any scene, portrait, or moment and receive an image rendered with authentic vintage instant-film aesthetics — faded warm colors, soft film grain, slight vignette, overexposed highlights, and that unmistakable '70s–'80s color palette, complete with a white polaroid border frame.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/polaroid-photo-generator
```

**Via ClawHub:**
```bash
clawhub install polaroid-photo-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node polaroidphotogenerator.js "<description>" --token YOUR_TOKEN [--size <size>] [--ref <uuid>]
```

### Examples

```bash
# Square polaroid of a sunset on the beach
node polaroidphotogenerator.js "golden hour sunset over a calm ocean beach" --token "$NETA_TOKEN"

# Portrait-oriented polaroid of a city street
node polaroidphotogenerator.js "busy 1970s New York City street corner, yellow cabs, pedestrians" --token "$NETA_TOKEN" --size portrait

# Landscape polaroid of a mountain cabin
node polaroidphotogenerator.js "rustic log cabin in a snowy mountain forest" --token "$NETA_TOKEN" --size landscape

# Tall polaroid of a lone figure
node polaroidphotogenerator.js "a woman in a sundress standing in a wildflower meadow" --token "$NETA_TOKEN" --size tall

# With a reference image UUID for style inheritance
node polaroidphotogenerator.js "children playing in a backyard" --token "$NETA_TOKEN" --ref abc123-uuid-here
```

### Output

Returns a direct image URL printed to stdout. Redirect or pipe it as needed:

```bash
URL=$(node polaroidphotogenerator.js "sunset over the ocean" --token "$NETA_TOKEN")
echo "Image: $URL"
```

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | _(required)_ | Your Neta API token |
| `--size` | `square`, `portrait`, `landscape`, `tall` | `square` | Output image dimensions |
| `--ref` | UUID string | _(none)_ | Reference image UUID for style inheritance |

### Size dimensions

| Size | Width | Height |
|------|-------|--------|
| `square` | 1024 | 1024 |
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `tall` | 704 | 1408 |

---

## How It Works

1. Your text description is combined with a built-in polaroid aesthetic prompt to produce the retro look automatically.
2. A generation task is submitted to the Neta API.
3. The script polls every 2 seconds (up to 3 minutes) until the image is ready.
4. The final image URL is printed to stdout.


FILE:package.json
{"name":"polaroid-photo-generator","version":"1.0.0","type":"module","description":"Polaroid Photo Generator — AI-powered polaroid photo generator ai","license":"MIT"}

FILE:polaroidphotogenerator.js
#!/usr/bin/env node
import { setTimeout as sleep } from "timers/promises";

const args = process.argv.slice(2);

function getFlag(name) {
  const idx = args.indexOf(name);
  return idx !== -1 ? args[idx + 1] : null;
}

const PROMPT_RAW = args.find((a) => !a.startsWith("--") && args.indexOf(a) === args.indexOf(a));
const positional = args.filter((a, i) => {
  if (a.startsWith("--")) return false;
  if (i > 0 && args[i - 1].startsWith("--")) return false;
  return true;
});
const PROMPT = positional[0];
const tokenFlag = getFlag("--token");
const sizeFlag = getFlag("--size") || "square";
const refFlag = getFlag("--ref");

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error("\n✗ Token required. Pass via: --token YOUR_TOKEN");
  console.error("  Get yours at: https://www.neta.art/open/");
  process.exit(1);
}

if (!PROMPT) {
  console.error("\n✗ Prompt required. Pass as first positional argument.");
  console.error('  Example: node polaroidphotogenerator.js "your prompt" --token YOUR_TOKEN');
  process.exit(1);
}

const SIZES = {
  square: { width: 1024, height: 1024 },
  portrait: { width: 832, height: 1216 },
  landscape: { width: 1216, height: 832 },
  tall: { width: 704, height: 1408 },
};

const { width, height } = SIZES[sizeFlag] || SIZES.square;

const HEADERS = {
  "x-token": TOKEN,
  "x-platform": "nieta-app/web",
  "content-type": "application/json",
};

const DEFAULT_PROMPT =
  "A vintage polaroid instant photograph with faded warm colors, soft film grain, slight vignette, overexposed highlights, authentic 1970s–1980s color palette, retro instant-film aesthetic, white polaroid border frame";

const fullPrompt = PROMPT
  ? `PROMPT. DEFAULT_PROMPT`
  : DEFAULT_PROMPT;

const body = {
  storyId: "DO_NOT_USE",
  jobType: "universal",
  rawPrompt: [{ type: "freetext", value: fullPrompt, weight: 1 }],
  width,
  height,
  meta: { entrance: "PICTURE,VERSE" },
  context_model_series: "8_image_edit",
};

if (refFlag) {
  body.inherit_params = {
    collection_uuid: refFlag,
    picture_uuid: refFlag,
  };
}

async function main() {
  console.error(`Generating polaroid photo: "PROMPT" (sizeFlag width×height)...`);

  const makeRes = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!makeRes.ok) {
    const text = await makeRes.text();
    console.error(`\n✗ API error makeRes.status: text`);
    process.exit(1);
  }

  const makeData = await makeRes.json();
  const task_uuid =
    typeof makeData === "string" ? makeData : makeData.task_uuid;

  if (!task_uuid) {
    console.error("\n✗ No task_uuid returned from API.");
    console.error(JSON.stringify(makeData));
    process.exit(1);
  }

  console.error(`Task started: task_uuid`);
  console.error("Polling for result...");

  const MAX_ATTEMPTS = 90;
  for (let i = 0; i < MAX_ATTEMPTS; i++) {
    await sleep(2000);

    const pollRes = await fetch(
      `https://api.talesofai.com/v1/artifact/task/task_uuid`,
      { headers: HEADERS }
    );

    if (!pollRes.ok) {
      console.error(`Poll attempt i + 1 failed: pollRes.status`);
      continue;
    }

    const pollData = await pollRes.json();
    const status = pollData.task_status;

    if (status === "PENDING" || status === "MODERATION") {
      process.stderr.write(".");
      continue;
    }

    process.stderr.write("\n");

    const url =
      pollData.artifacts?.[0]?.url || pollData.result_image_url;

    if (!url) {
      console.error("\n✗ No image URL in response.");
      console.error(JSON.stringify(pollData));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error("\n✗ Timed out waiting for image generation.");
  process.exit(1);
}

main().catch((err) => {
  console.error("\n✗ Unexpected error:", err.message);
  process.exit(1);
});

---
name: vintage-poster-generator
description: AI vintage poster generator — create retro art prints, old-school travel posters, 1950s-1970s style illustrations, antique advertising art, and nostalgic wall art from any text prompt. Perfect for Etsy sellers, interior designers, and retro aesthetic lovers seeking vintage-style digital art, aged poster designs, and classic print visuals via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Vintage Poster Generator

AI vintage poster generator — create retro art prints, old-school travel posters, 1950s-1970s style illustrations, antique advertising art, and nostalgic wall art from any text prompt. Perfect for Etsy sellers, interior designers, and retro aesthetic lovers seeking vintage-style digital art, aged poster designs, and classic print visuals.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create vintage poster generator images.

## Quick start
```bash
node vintagepostergenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/vintage-poster-generator
```

FILE:README.md
# Vintage Poster Generator

Generate stunning vintage-style poster images from text descriptions. Describe any scene, subject, or concept and receive a retro art print in 1950s–1970s aesthetic — complete with aged paper texture, distressed print effects, muted warm color palettes, and classic typography layouts. Great for Etsy sellers, interior designers, and anyone who loves nostalgic wall art.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/vintage-poster-generator
```

**Via ClawHub:**
```bash
clawhub install vintage-poster-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node vintagepostergenerator.js "<description>" --token YOUR_TOKEN [--size <size>] [--ref <uuid>]
```

### Examples

```bash
# Classic travel poster
node vintagepostergenerator.js "Paris travel poster, Eiffel Tower at sunset, art deco style" --token YOUR_TOKEN

# Retro music concert poster
node vintagepostergenerator.js "jazz festival poster, 1960s style, bold geometric shapes, trumpet player silhouette" --token YOUR_TOKEN

# Vintage national park poster
node vintagepostergenerator.js "Yellowstone national park vintage poster, old faithful geyser, WPA style illustration" --token YOUR_TOKEN

# Landscape orientation
node vintagepostergenerator.js "Route 66 road trip poster, desert highway, retro americana" --token YOUR_TOKEN --size landscape

# Tall format
node vintagepostergenerator.js "1950s diner advertisement, neon signs, chrome details" --token YOUR_TOKEN --size tall
```

**Output:** Returns a direct image URL.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | *(required)* | Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--ref` | UUID string | *(none)* | Reference image UUID for style inheritance |

### Size dimensions

| Size | Dimensions |
|------|-----------|
| `portrait` | 832 × 1216 |
| `landscape` | 1216 × 832 |
| `square` | 1024 × 1024 |
| `tall` | 704 × 1408 |

---

## Default Style

When no prompt is provided, the skill generates using this default:

> vintage retro poster design, aged paper texture, distressed print effect, muted warm color palette, classic typography layout, 1950s-1970s aesthetic, high contrast illustration style, collectible art print


FILE:package.json
{
  "name": "vintage-poster-generator",
  "version": "1.0.1",
  "type": "module",
  "description": "Vintage Poster Generator — AI-powered vintage poster generator ai",
  "license": "MIT"
}

FILE:vintagepostergenerator.js
#!/usr/bin/env node
// Vintage Poster Generator — AI-powered retro poster image generation via Neta API

const args = process.argv.slice(2);

// Parse CLI arguments
let prompt = null;
let size = 'portrait';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'vintage retro poster design, aged paper texture, distressed print effect, muted warm color palette, classic typography layout, 1950s-1970s aesthetic, high contrast illustration style, collectible art print';
}

const SIZES = {
  square:   { width: 1024, height: 1024 },
  portrait: { width: 832,  height: 1216 },
  landscape:{ width: 1216, height: 832  },
  tall:     { width: 704,  height: 1408 },
};

const { width, height } = SIZES[size] ?? SIZES.portrait;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

async function makeImage() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width,
    height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    body.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    console.error(`✗ Failed to create task (res.status): text`);
    process.exit(1);
  }

  const data = await res.json();
  const taskUuid = typeof data === 'string' ? data : data.task_uuid;

  if (!taskUuid) {
    console.error('✗ No task_uuid in response:', JSON.stringify(data));
    process.exit(1);
  }

  return taskUuid;
}

async function pollTask(taskUuid) {
  const maxAttempts = 90;
  const intervalMs = 2000;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    await new Promise(r => setTimeout(r, intervalMs));

    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: HEADERS,
    });

    if (!res.ok) {
      console.error(`✗ Poll failed (res.status)`);
      process.exit(1);
    }

    const data = await res.json();
    const status = data.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      continue;
    }

    // Task is done
    const url =
      data.artifacts?.[0]?.url ??
      data.result_image_url ??
      null;

    if (!url) {
      console.error('✗ Task finished but no image URL found:', JSON.stringify(data));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error('✗ Timed out waiting for image generation.');
  process.exit(1);
}

const taskUuid = await makeImage();
await pollTask(taskUuid);

---
name: neon-art-generator
description: AI neon art generator that transforms any subject into stunning neon-lit artwork. Create glowing neon portraits, cyberpunk neon scenes, neon sign aesthetics, and vibrant electric art. Perfect for profile pictures, wallpapers, social media content, and digital art with neon glow, neon lights, and neon aesthetic styles via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Neon Art Generator

AI neon art generator that transforms any subject into stunning neon-lit artwork. Create glowing neon portraits, cyberpunk neon scenes, neon sign aesthetics, and vibrant electric art. Perfect for profile pictures, wallpapers, social media content, and digital art with neon glow, neon lights, and neon aesthetic styles.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create neon art generator images.

## Quick start
```bash
node neonartgenerator.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/neon-art-generator
```

FILE:README.md
# Neon Art Generator

Generate stunning neon-lit artwork from text descriptions using AI. Describe any subject — a portrait, a cityscape, an object — and receive vibrant neon-glowing images with electric blues, pinks, and cyberpunk aesthetics. Ideal for profile pictures, wallpapers, social media content, and digital art projects.

Powered by the Neta AI image generation API (api.talesofai.com) — the same service as neta.art/open.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/neon-art-generator
```

**Via ClawHub:**
```bash
clawhub install neon-art-generator
```

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Usage

```bash
node neonartgenerator.js "PROMPT" --token YOUR_TOKEN [--size SIZE] [--ref UUID]
```

### Examples

```bash
# Neon portrait
node neonartgenerator.js "neon glowing portrait, electric blue and pink neon lights, dark background" --token "$NETA_TOKEN"

# Cyberpunk city scene
node neonartgenerator.js "cyberpunk city at night, neon signs, rain reflections, ultra detailed" --token "$NETA_TOKEN"

# Landscape format
node neonartgenerator.js "neon jungle, glowing plants, vibrant neon colors" --token "$NETA_TOKEN" --size landscape

# Using a reference image for style inheritance
node neonartgenerator.js "neon samurai warrior" --token "$NETA_TOKEN" --ref abc123-uuid-here
```

The script prints the generated image URL to stdout when complete.

**Output:** Returns a direct image URL.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--token` | string | _(required)_ | Your Neta API token |
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--ref` | UUID string | _(none)_ | Reference image UUID for style inheritance |

### Size Dimensions

| Size | Width | Height |
|------|-------|--------|
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `square` | 1024 | 1024 |
| `tall` | 704 | 1408 |

---

## Default Prompt

If no prompt is provided, the following default is used:

> neon glowing portrait, vibrant neon lights, electric blue and pink neon colors, dark background, cinematic lighting, neon reflections, cyberpunk neon aesthetic, high contrast, ultra detailed


FILE:neonartgenerator.js
#!/usr/bin/env node
// Neon Art Generator — AI-powered neon art generation via Neta API

const args = process.argv.slice(2);

// Parse CLI arguments
let prompt = null;
let size = 'portrait';
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--token' && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === '--size' && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === '--ref' && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith('--') && prompt === null) {
    prompt = args[i];
  }
}

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n✗ Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'neon glowing portrait, vibrant neon lights, electric blue and pink neon colors, dark background, cinematic lighting, neon reflections, cyberpunk neon aesthetic, high contrast, ultra detailed';
}

const SIZES = {
  square:    { width: 1024, height: 1024 },
  portrait:  { width: 832,  height: 1216 },
  landscape: { width: 1216, height: 832  },
  tall:      { width: 704,  height: 1408 },
};

const dimensions = SIZES[size] || SIZES.portrait;

const HEADERS = {
  'x-token': TOKEN,
  'x-platform': 'nieta-app/web',
  'content-type': 'application/json',
};

async function makeImage() {
  const body = {
    storyId: 'DO_NOT_USE',
    jobType: 'universal',
    rawPrompt: [{ type: 'freetext', value: prompt, weight: 1 }],
    width: dimensions.width,
    height: dimensions.height,
    meta: { entrance: 'PICTURE,VERSE' },
    context_model_series: '8_image_edit',
  };

  if (refUuid) {
    body.inherit_params = {
      collection_uuid: refUuid,
      picture_uuid: refUuid,
    };
  }

  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    console.error(`✗ Failed to create image task (res.status): text`);
    process.exit(1);
  }

  const data = await res.json();
  const taskUuid = typeof data === 'string' ? data : data.task_uuid;

  if (!taskUuid) {
    console.error('✗ No task_uuid returned:', JSON.stringify(data));
    process.exit(1);
  }

  console.error(`Generating neon art... (task: taskUuid)`);

  // Poll for result
  const maxAttempts = 90;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    await new Promise(r => setTimeout(r, 2000));

    const pollRes = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: HEADERS,
    });

    if (!pollRes.ok) {
      console.error(`✗ Poll failed (pollRes.status)`);
      process.exit(1);
    }

    const result = await pollRes.json();
    const status = result.task_status;

    if (status === 'PENDING' || status === 'MODERATION') {
      process.stderr.write('.');
      continue;
    }

    // Done
    process.stderr.write('\n');
    const url =
      result.artifacts?.[0]?.url ||
      result.result_image_url;

    if (!url) {
      console.error('✗ No image URL in response:', JSON.stringify(result));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error('\n✗ Timed out waiting for image generation.');
  process.exit(1);
}

makeImage().catch(err => {
  console.error('✗ Unexpected error:', err.message);
  process.exit(1);
});

FILE:package.json
{"name":"neon-art-generator","version":"1.0.0","type":"module","description":"Neon Art Generator — AI-powered neon art generator ai","license":"MIT"}

---
name: ai-headshot-skill
description: Generate ai professional headshot generator images with AI via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# AI Professional Headshot Generator

Generate stunning ai professional headshot generator images from a text description. Get back a direct image URL instantly.

## Token

Requires a Neta API token (free trial at <https://www.neta.art/open/>). Pass it via the `--token` flag.

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## When to use
Use when someone asks to generate or create ai professional headshot generator images.

## Quick start
```bash
node aiheadshot.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `portrait`)
- `--ref` — reference image UUID for style inheritance

## Install
```bash
npx skills add blammectrappora/ai-headshot-skill
```

FILE:README.md
# AI Professional Headshot Generator

> Powered by the **Neta AI image generation API** (`api.talesofai.com`) — the same service as [neta.art](https://www.neta.art/open/).

Generate polished, photorealistic professional headshots from a text description using AI. Powered by the Neta talesofai API — get a direct image URL back in seconds.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/ai-headshot-skill
```

**Via ClawHub:**
```bash
clawhub install ai-headshot-skill
```

---

## Usage

```bash
# Default prompt (studio headshot)
node aiheadshot.js

# Custom prompt
node aiheadshot.js "executive headshot, woman in blazer, blurred office background"

# With size option
node aiheadshot.js "confident professional headshot" --size landscape

# With a reference image UUID
node aiheadshot.js "same person, different background" --ref <picture_uuid>
```

The script prints a single image URL to stdout on success.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--token` | string | — | Neta API token (required) |
| `--ref` | picture_uuid | — | Reference image UUID for style inheritance |

### Size dimensions

| Name | Width × Height |
|------|---------------|
| `square` | 1024 × 1024 |
| `portrait` | 832 × 1216 |
| `landscape` | 1216 × 832 |
| `tall` | 704 × 1408 |

---

## Token setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Examples

```bash
# Portrait headshot (default)
node aiheadshot.js "professional studio headshot, man in suit, neutral grey background"

# Square crop for profile pictures
node aiheadshot.js "friendly professional headshot, warm smile" --size square

# Landscape for LinkedIn banner
node aiheadshot.js "executive portrait, woman, modern office background" --size landscape
```

## Example Output

![Generated example](https://cdn.talesofai.com/picture/66f12b83-2349-4c05-ab43-16dfae9fb943.webp)

FILE:aiheadshot.js
#!/usr/bin/env node

// --- Argument parsing ---
const args = process.argv.slice(2);
let prompt = null;
let size = "portrait";
let token = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--size" && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === "--token" && args[i + 1]) {
    token = args[++i];
  } else if (args[i] === "--ref" && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith("--") && prompt === null) {
    prompt = args[i];
  }
}

if (!prompt) {
  prompt =
    "professional studio headshot of a person, clean neutral background, soft studio lighting, sharp focus on face, business casual attire, confident natural expression, high resolution, photorealistic";
}

// --- Token resolution ---
if (!token) {
  console.error(
    '\n✗ Token required. Pass via: --token YOUR_TOKEN'
  );
  process.exit(1);
}

// --- Size map ---
const SIZE_MAP = {
  square: { width: 1024, height: 1024 },
  portrait: { width: 832, height: 1216 },
  landscape: { width: 1216, height: 832 },
  tall: { width: 704, height: 1408 },
};

const dimensions = SIZE_MAP[size] || SIZE_MAP.portrait;

// --- Headers ---
const HEADERS = {
  "x-token": token,
  "x-platform": "nieta-app/web",
  "content-type": "application/json",
};

// --- Build request body ---
const body = {
  storyId: "DO_NOT_USE",
  jobType: "universal",
  rawPrompt: [{ type: "freetext", value: prompt, weight: 1 }],
  width: dimensions.width,
  height: dimensions.height,
  meta: { entrance: "PICTURE,VERSE" },
  context_model_series: "8_image_edit",
};

if (refUuid) {
  body.inherit_params = {
    collection_uuid: refUuid,
    picture_uuid: refUuid,
  };
}

// --- POST to generate image ---
async function generateImage() {
  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    console.error(`Error creating task (res.status): text`);
    process.exit(1);
  }

  const data = await res.json();
  const taskUuid =
    typeof data === "string" ? data : data.task_uuid;

  if (!taskUuid) {
    console.error("Error: no task_uuid in response:", JSON.stringify(data));
    process.exit(1);
  }

  return taskUuid;
}

// --- Poll for result ---
async function pollTask(taskUuid) {
  const maxAttempts = 90;
  const delayMs = 2000;

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    await new Promise((r) => setTimeout(r, delayMs));

    const res = await fetch(
      `https://api.talesofai.com/v1/artifact/task/taskUuid`,
      { headers: HEADERS }
    );

    if (!res.ok) {
      console.error(`Poll error (res.status): await res.text()`);
      process.exit(1);
    }

    const data = await res.json();
    const status = data.task_status;

    if (status === "PENDING" || status === "MODERATION") {
      continue;
    }

    // Done — extract URL
    const url =
      data.artifacts?.[0]?.url ||
      data.result_image_url;

    if (!url) {
      console.error("Error: task done but no image URL found:", JSON.stringify(data));
      process.exit(1);
    }

    console.log(url);
    process.exit(0);
  }

  console.error("Error: timed out waiting for image generation");
  process.exit(1);
}

// --- Main ---
(async () => {
  const taskUuid = await generateImage();
  await pollTask(taskUuid);
})();

FILE:package.json
{
  "name": "ai-headshot-skill",
  "version": "2.1.0",
  "type": "module",
  "description": "AI Professional Headshot Generator — AI-powered ai professional headshot generator",
  "license": "MIT"
}

---
name: vtuber-avatar-skill
description: Generate vtuber avatar creator ai images with AI via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# VTuber Avatar Generator

Generate stunning vtuber avatar creator ai images from a text description. Get back a direct image URL instantly.

## Token

Requires a Neta API token. Free trial available at <https://www.neta.art/open/>.

```bash
export NETA_TOKEN=your_token_here
node <script> "your prompt" --token "$NETA_TOKEN"
```

## When to use
Use when someone asks to generate or create vtuber avatar creator images.

## Quick start
```bash
node vtuberavatar.js "your description here" --token YOUR_TOKEN
```

## Options
- `--size` — `portrait`, `landscape`, `square`, `tall` (default: `square`)
- `--style` — `anime`, `cinematic`, `realistic` (default: `anime`)

## Install
```bash
npx skills add blammectrappora/vtuber-avatar-skill
```

FILE:README.md
# VTuber Avatar Generator

> Powered by the **Neta AI image generation API** (`api.talesofai.com`) — the same service as [neta.art](https://www.neta.art/open/).

Generate professional VTuber avatar images from text descriptions using AI. Powered by the Neta talesofai API, this skill produces anime-style virtual streamer character art — ready for Live2D rigging and streaming.

---

## Install

**Via npx skills:**
```bash
npx skills add blammectrappora/vtuber-avatar-skill
```

**Via ClawHub:**
```bash
clawhub install vtuber-avatar-skill
```

---

## Usage

**Basic — uses the default VTuber prompt:**
```bash
node vtuberavatar.js
```

**Custom prompt:**
```bash
node vtuberavatar.js "fox girl vtuber, silver hair with blue highlights, golden eyes, shrine maiden outfit, cozy lo-fi aesthetic"
```

**With size option:**
```bash
node vtuberavatar.js "cute bunny vtuber, pastel pink hair, oversized hoodie" --size portrait
```

**With a reference image (for style inheritance):**
```bash
node vtuberavatar.js "same character, winter outfit" --ref <picture_uuid>
```

**Pass token inline:**
```bash
node vtuberavatar.js "dragon vtuber, scales, fierce expression" --token YOUR_TOKEN
```

The script prints a direct image URL to stdout on success.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--size` | `square`, `portrait`, `landscape`, `tall` | `square` | Output image dimensions |
| `--token` | string | — | Override token (see Token Setup) |
| `--ref` | picture_uuid | — | Inherit style from an existing image |

### Size dimensions

| Name | Width | Height |
|------|-------|--------|
| `square` | 1024 | 1024 |
| `portrait` | 832 | 1216 |
| `landscape` | 1216 | 832 |
| `tall` | 704 | 1408 |

---

## Token Setup

This skill requires a Neta API token (free trial available at <https://www.neta.art/open/>).

Pass it via the `--token` flag:

```bash
node <script> "your prompt" --token YOUR_TOKEN
```

## Default Prompt

When no prompt is provided, the skill uses:

> VTuber avatar, anime style, vibrant hair, expressive eyes, live2d ready, clean lines, professional virtual streamer character design, soft pastel background

## Example Output

![Generated example](https://oss.talesofai.cn/picture/9a2f7875-59c9-4d9b-a59e-c3ae9f1deafc.webp)

---

This skill requires a Neta API token (free trial available at https://www.neta.art/open/).

FILE:package.json
{
  "name": "vtuber-avatar-skill",
  "version": "2.0.1",
  "type": "module",
  "description": "VTuber Avatar Generator \u2014 AI-powered vtuber avatar creator ai",
  "license": "MIT",
  "clawhub": {
    "env": [
      {
        "name": "NETA_TOKEN",
        "description": "Neta AI API token. Get it at https://www.neta.art/open/",
        "required": true
      }
    ]
  }
}

FILE:vtuberavatar.js
#!/usr/bin/env node

// --- Argument parsing ---
const args = process.argv.slice(2);
let prompt = null;
let size = "square";
let tokenFlag = null;
let refUuid = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--size" && args[i + 1]) {
    size = args[++i];
  } else if (args[i] === "--token" && args[i + 1]) {
    tokenFlag = args[++i];
  } else if (args[i] === "--ref" && args[i + 1]) {
    refUuid = args[++i];
  } else if (!args[i].startsWith("--") && prompt === null) {
    prompt = args[i];
  }
}

if (!prompt) {
  prompt =
    "VTuber avatar, anime style, vibrant hair, expressive eyes, live2d ready, clean lines, professional virtual streamer character design, soft pastel background";
}

// --- Token resolution ---
const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error(
    '\n✗ Token required. Pass via: --token YOUR_TOKEN'
  );
  process.exit(1);
}

// --- Size map ---
const SIZES = {
  square: { width: 1024, height: 1024 },
  portrait: { width: 832, height: 1216 },
  landscape: { width: 1216, height: 832 },
  tall: { width: 704, height: 1408 },
};

const dims = SIZES[size] || SIZES.square;

// --- Headers ---
const HEADERS = {
  "x-token": TOKEN,
  "x-platform": "nieta-app/web",
  "content-type": "application/json",
};

// --- Build request body ---
const body = {
  storyId: "DO_NOT_USE",
  jobType: "universal",
  rawPrompt: [{ type: "freetext", value: prompt, weight: 1 }],
  width: dims.width,
  height: dims.height,
  meta: { entrance: "PICTURE,VERSE" },
  context_model_series: "8_image_edit",
};

if (refUuid) {
  body.inherit_params = {
    collection_uuid: refUuid,
    picture_uuid: refUuid,
  };
}

// --- POST to make_image ---
async function makeImage() {
  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    throw new Error(`make_image failed (res.status): text`);
  }

  const data = await res.json();

  let taskUuid;
  if (typeof data === "string") {
    taskUuid = data;
  } else if (data && data.task_uuid) {
    taskUuid = data.task_uuid;
  } else {
    throw new Error(`Unexpected make_image response: JSON.stringify(data)`);
  }

  return taskUuid;
}

// --- Poll for result ---
async function pollTask(taskUuid) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  const MAX_ATTEMPTS = 90;
  const INTERVAL_MS = 2000;

  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
    await new Promise((r) => setTimeout(r, INTERVAL_MS));

    const res = await fetch(url, { headers: HEADERS });

    if (!res.ok) {
      const text = await res.text();
      throw new Error(`poll failed (res.status): text`);
    }

    const data = await res.json();
    const status = data.task_status;

    if (status === "PENDING" || status === "MODERATION") {
      continue;
    }

    // Done — extract image URL
    const imageUrl =
      (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;

    if (!imageUrl) {
      throw new Error(`No image URL in response: JSON.stringify(data)`);
    }

    return imageUrl;
  }

  throw new Error(`Timed out waiting for task taskUuid after MAX_ATTEMPTS attempts`);
}

// --- Main ---
(async () => {
  try {
    const taskUuid = await makeImage();
    const imageUrl = await pollTask(taskUuid);
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error("Error:", err.message);
    process.exit(1);
  }
})();