blammectrappora

---
name: impossible-scene-generator
description: Generate photorealistic impossible scenes and anti-physics landscapes powered by AI — crystal mountains with auroras, floating islands, organic-growing buildings, surreal cinematic environments, and dreamlike sci-fi vistas. Perfect for desktop wallpapers, concept art, book covers, album art, sci-fi posters, fantasy worldbuilding, and print-on-demand artwork via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Impossible Scene Generator

Generate photorealistic impossible scenes and anti-physics landscapes powered by AI — crystal mountains with auroras, floating islands, organic-growing buildings, surreal cinematic environments, and dreamlike sci-fi vistas. Perfect for desktop wallpapers, concept art, book covers, album art, sci-fi posters, fantasy worldbuilding, and print-on-demand artwork.

## 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 impossible scene generator images.

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

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

## Install
```bash
npx skills add blammectrappora/impossible-scene-generator
```

FILE:README.md
# Impossible Scene Generator

Generate photorealistic impossible scenes and anti-physics landscapes from text descriptions. Describe what you want — crystal mountains beneath cosmic auroras, floating islands defying gravity, organic-growing architecture, dreamlike sci-fi vistas — and get back a high-resolution cinematic image. Ideal for desktop wallpapers, concept art, book covers, album art, sci-fi posters, fantasy worldbuilding, and print-on-demand artwork.

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

## Install

```bash
npx skills add blammectrappora/impossible-scene-generator
```

Or via ClawHub:

```bash
clawhub install impossible-scene-generator
```

## Usage

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

### Examples

```bash
node impossiblescenegenerator.js "crystal mountains beneath twin moons and cosmic auroras, ultra-wide cinematic vista" --token YOUR_TOKEN

node impossiblescenegenerator.js "floating islands with cascading waterfalls into clouds, hyperdetailed photography" --size landscape --token YOUR_TOKEN

node impossiblescenegenerator.js "organic-growing alien city of bone and coral, dramatic volumetric lighting" --size portrait --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `--size` | Aspect: `portrait` (832×1216), `landscape` (1216×832), `square` (1024×1024), `tall` (704×1408) | `landscape` |
| `--token` | Your Neta API token (required) | — |
| `--ref` | Reference image UUID for style inheritance | — |

## Output

Returns a direct image URL.

## Token setup

This skill requires a Neta API token. Pass it via the `--token` flag on every invocation:

```bash
node impossiblescenegenerator.js "a surreal anti-physics landscape" --token YOUR_TOKEN
```

You can keep the token in a shell variable and expand it inline:

```bash
node impossiblescenegenerator.js "a surreal anti-physics landscape" --token "$NETA_TOKEN"
```

Get a free trial token at <https://www.neta.art/open/>.


FILE:impossiblescenegenerator.js
#!/usr/bin/env node
import process from 'node:process';

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

const DEFAULT_PROMPT = 'a photorealistic impossible landscape, crystal mountains beneath cosmic auroras, organic-growing architecture, anti-physics floating islands, hyperdetailed cinematic photography, dramatic volumetric lighting, ultra-wide vista, 8k quality, awe-inspiring atmosphere';

function parseArgs(argv) {
  const args = { size: 'landscape' };
  const positional = [];
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (a === '--size') args.size = argv[++i];
    else if (a === '--token') args.token = argv[++i];
    else if (a === '--ref') args.ref = argv[++i];
    else positional.push(a);
  }
  args.prompt = positional.join(' ').trim();
  return args;
}

async function main() {
  const { prompt, size, token: tokenFlag, ref } = parseArgs(process.argv.slice(2));

  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);
  }

  const PROMPT = prompt || DEFAULT_PROMPT;
  const dims = SIZES[size] || SIZES.landscape;

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

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  console.error(`→ Generating dims.width×dims.height: "PROMPT"`);

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

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

  const submitData = await submitRes.json().catch(async () => await submitRes.text());
  const taskUuid = typeof submitData === 'string' ? submitData : submitData.task_uuid;

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

  console.error(`→ Task taskUuid submitted, polling…`);

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

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

    if (!pollRes.ok) {
      console.error(`  poll attempt + 1: HTTP pollRes.status`);
      continue;
    }

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

    if (status === 'PENDING' || status === 'MODERATION') {
      if (attempt % 5 === 0) console.error(`  poll attempt + 1: status`);
      continue;
    }

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

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

    console.error('✗ Task done but no image URL:', JSON.stringify(data));
    process.exit(1);
  }

  console.error('✗ Timed out after 90 polls (~3 minutes)');
  process.exit(1);
}

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

FILE:package.json
{"name":"impossible-scene-generator","version":"1.0.0","type":"module","description":"Impossible Scene Generator — AI-powered impossible scene generator ai","license":"MIT"}

---
name: cosplay-reference-generator
description: Generate cosplay reference sheets and costume design illustrations from any character or outfit description. Perfect for cosplayers planning builds, commissioning costumes, anime convention prep, costume photoshoot planning, Etsy seller listings, and cosplay tutorials. Creates full-body character references with detailed outfit visualization, multiple angles, and accessory details via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Cosplay Reference Generator

Generate cosplay reference sheets and costume design illustrations from any character or outfit description. Perfect for cosplayers planning builds, commissioning costumes, anime convention prep, costume photoshoot planning, Etsy seller listings, and cosplay tutorials. Creates full-body character references with detailed outfit visualization, multiple angles, and accessory details.

## 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 cosplay reference sheet generator images.

## Quick start
```bash
node cosplayreferencegenerator.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/cosplay-reference-generator
```

FILE:README.md
# Cosplay Reference Generator

Generate cosplay reference sheets and costume design illustrations from text descriptions. Describe any character or outfit and get a full-body anime-style reference sheet — ideal for cosplayers planning builds, commissioning costumes, prepping for anime conventions, organizing photoshoots, populating Etsy listings, or producing cosplay tutorials.

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

## Install

```bash
npx skills add blammectrappora/cosplay-reference-generator
```

Or with ClawHub:

```bash
clawhub install cosplay-reference-generator
```

## Usage

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

### Examples

```bash
node cosplayreferencegenerator.js "magical girl with star wand and pastel pink dress" --token YOUR_TOKEN
```

```bash
node cosplayreferencegenerator.js "cyberpunk samurai with neon katana and tactical armor" --size portrait --token YOUR_TOKEN
```

```bash
node cosplayreferencegenerator.js "fantasy elf ranger in forest green leather armor" --size tall --token YOUR_TOKEN
```

## Options

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

### Sizes

| Name | Dimensions |
| --- | --- |
| `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
```

## Output

Returns a direct image URL.


FILE:cosplayreferencegenerator.js
#!/usr/bin/env node
import process from 'node:process';

const DEFAULT_PROMPT = 'full body cosplay character reference sheet, T-pose front view, detailed costume design, vibrant colors, clean white background, professional reference art, full outfit visible, multiple costume details';
const STYLE_SUFFIX = 'anime';

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

function parseArgs(argv) {
  const args = { positional: [], size: 'portrait', token: null, ref: null };
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (a === '--size') {
      args.size = argv[++i];
    } else if (a === '--token') {
      args.token = argv[++i];
    } else if (a === '--ref') {
      args.ref = argv[++i];
    } else if (a.startsWith('--size=')) {
      args.size = a.slice('--size='.length);
    } else if (a.startsWith('--token=')) {
      args.token = a.slice('--token='.length);
    } else if (a.startsWith('--ref=')) {
      args.ref = a.slice('--ref='.length);
    } else {
      args.positional.push(a);
    }
  }
  return args;
}

async function main() {
  const args = parseArgs(process.argv.slice(2));
  const tokenFlag = args.token;
  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);
  }

  const userPrompt = args.positional[0];
  const PROMPT = userPrompt
    ? `DEFAULT_PROMPT, userPrompt, STYLE_SUFFIX`
    : `DEFAULT_PROMPT, STYLE_SUFFIX`;

  const sizeKey = SIZES[args.size] ? args.size : 'portrait';
  const { width, height } = SIZES[sizeKey];

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

  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 (args.ref) {
    body.inherit_params = {
      collection_uuid: args.ref,
      picture_uuid: args.ref,
    };
  }

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

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

  const submitText = await submitRes.text();
  let task_uuid;
  try {
    const parsed = JSON.parse(submitText);
    task_uuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    task_uuid = submitText.replace(/^"|"$/g, '').trim();
  }

  if (!task_uuid) {
    console.error('\n✗ No task_uuid returned');
    process.exit(1);
  }

  for (let attempt = 0; attempt < 90; attempt++) {
    await new Promise((r) => setTimeout(r, 2000));
    const pollRes = await fetch(
      `https://api.talesofai.com/v1/artifact/task/task_uuid`,
      { headers },
    );
    if (!pollRes.ok) continue;
    const data = await pollRes.json();
    const status = data.task_status;
    if (status === 'PENDING' || status === 'MODERATION') continue;

    const url =
      (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;
    if (url) {
      console.log(url);
      process.exit(0);
    }
    console.error(`\n✗ Task finished without image. Status: status`);
    process.exit(1);
  }

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

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

FILE:package.json
{
  "name": "cosplay-reference-generator",
  "version": "1.0.1",
  "type": "module",
  "description": "Cosplay Reference Generator — AI-powered cosplay reference sheet generator",
  "license": "MIT"
}

---
name: art-deco-generator
description: Art deco generator that creates 1920s-inspired Gatsby-style art deco posters, prints, wedding invitations, luxury branding, and Pinterest-worthy art deco illustrations with geometric patterns, gold and black palettes, sunburst motifs, chevron designs, and ornate vintage glamour aesthetics. Perfect for art deco wallpaper, art deco wall art, art deco logo design, art deco poster generator, roaring twenties art, vintage luxury design, geometric pattern generator, and 1920s aesthetic AI art creation via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Art Deco Generator

Art deco generator that creates 1920s-inspired Gatsby-style art deco posters, prints, wedding invitations, luxury branding, and Pinterest-worthy art deco illustrations with geometric patterns, gold and black palettes, sunburst motifs, chevron designs, and ornate vintage glamour aesthetics. Perfect for art deco wallpaper, art deco wall art, art deco logo design, art deco poster generator, roaring twenties art, vintage luxury design, geometric pattern generator, and 1920s aesthetic AI art creation.

## 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 art deco design generator images.

## Quick start
```bash
node artdecogenerator.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/art-deco-generator
```

FILE:README.md
# Art Deco Generator

Generate stunning 1920s-inspired art deco illustrations from text descriptions — Gatsby-style posters, wedding invitations, luxury branding, geometric patterns, sunburst motifs, chevron designs, and ornate vintage glamour aesthetics with gold and black palettes.

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

## Install

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

Or via ClawHub:

```bash
clawhub install art-deco-generator
```

## Usage

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

### Examples

```bash
# Default art deco prompt
node artdecogenerator.js "" --token YOUR_TOKEN

# Custom prompt
node artdecogenerator.js "art deco wedding invitation, gold sunburst, black background" --token YOUR_TOKEN

# Landscape poster
node artdecogenerator.js "1920s Gatsby skyline poster" --size landscape --token YOUR_TOKEN

# Style inheritance from a reference image
node artdecogenerator.js "art deco peacock motif" --ref <picture_uuid> --token YOUR_TOKEN
```

## Options

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

### Sizes

| Name | Dimensions |
| --- | --- |
| `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
```

## Output

Returns a direct image URL.


FILE:artdecogenerator.js
#!/usr/bin/env node
import { argv, exit, stdout } from 'node:process';

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

const DEFAULT_PROMPT = 'art deco style illustration, geometric patterns, symmetrical sunburst motifs, gold and black color palette, ornate metallic details, 1920s Gatsby aesthetic, luxurious art deco design, stepped fan shapes, chevron and zigzag patterns, elegant typography ornamentation, high contrast, opulent vintage glamour';

function parseArgs(args) {
  let prompt = null;
  let size = 'portrait';
  let tokenFlag = null;
  let ref = null;

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

  return { prompt, size, tokenFlag, ref };
}

async function main() {
  const { prompt, size, tokenFlag, ref } = parseArgs(argv.slice(2));

  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);
  }

  const PROMPT = prompt || DEFAULT_PROMPT;
  const dims = SIZES[size] || SIZES.portrait;

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

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  console.error(`→ Submitting prompt (dims.width×dims.height)...`);

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

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

  const submitText = await submitRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(submitText);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = submitText.replace(/^"|"$/g, '').trim();
  }

  if (!taskUuid) {
    console.error(`✗ No task_uuid in response: submitText`);
    process.exit(1);
  }

  console.error(`→ Task taskUuid, polling...`);

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

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

    if (!pollRes.ok) {
      continue;
    }

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

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

    const url = data.artifacts?.[0]?.url || data.result_image_url;
    if (url) {
      stdout.write(url + '\n');
      process.exit(0);
    }

    console.error(`✗ Task finished (status) but no image URL: JSON.stringify(data)`);
    process.exit(1);
  }

  console.error('✗ Timed out after 90 attempts (180s).');
  process.exit(1);
}

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

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

---
name: isekai-character-generator
description: Generate isekai anime characters and light novel protagonists — design transported-to-another-world heroes, JRPG main characters, fantasy adventurers, magical girls, demon lords, and reincarnated MCs in the Niji-style anime aesthetic popular in shows like Sword Art Online, Re:Zero, Mushoku Tensei, and That Time I Got Reincarnated as a Slime. Perfect for fanart, OC design, light novel covers, manga concept art, and character sheets via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Isekai Character Generator

Generate isekai anime characters and light novel protagonists — design transported-to-another-world heroes, JRPG main characters, fantasy adventurers, magical girls, demon lords, and reincarnated MCs in the Niji-style anime aesthetic popular in shows like Sword Art Online, Re:Zero, Mushoku Tensei, and That Time I Got Reincarnated as a Slime. Perfect for fanart, OC design, light novel covers, manga concept art, and character sheets.

## 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 isekai character art generator images.

## Quick start
```bash
node isekaicharactergenerator.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/isekai-character-generator
```

FILE:README.md
# Isekai Character Generator

Generate isekai anime characters and light novel protagonists from text descriptions — design transported-to-another-world heroes, JRPG main characters, fantasy adventurers, magical girls, demon lords, and reincarnated MCs in the Niji-style anime aesthetic popular in shows like *Sword Art Online*, *Re:Zero*, *Mushoku Tensei*, and *That Time I Got Reincarnated as a Slime*. Perfect for fanart, OC design, light novel covers, manga concept art, and character sheets.

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

## Install

```bash
npx skills add blammectrappora/isekai-character-generator
```

Or with ClawHub:

```bash
clawhub install isekai-character-generator
```

## Usage

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

### Examples

Generate a default isekai protagonist:

```bash
node isekaicharactergenerator.js "anime style isekai protagonist character, transported to a fantasy other-world, magical sword and ornate armor, vibrant Niji-style colors, dramatic cinematic lighting, light novel cover art composition, detailed face and outfit, full body character design sheet" --token YOUR_TOKEN
```

A magical girl reincarnated as a demon lord:

```bash
node isekaicharactergenerator.js "magical girl reincarnated as a demon lord, dark ornate dress, glowing crimson eyes, floating magical runes, dramatic backlighting, Niji-style anime art" --token YOUR_TOKEN
```

A reluctant shounen hero in a JRPG party:

```bash
node isekaicharactergenerator.js "teenage shounen isekai hero, brown spiky hair, leather armor over school uniform, holding an ancient tome, flanked by elf and beastkin companions, light novel cover composition" --size landscape --token YOUR_TOKEN
```

Use a reference image for style inheritance:

```bash
node isekaicharactergenerator.js "demon lord sitting on a throne, ornate horns, regal robes" --ref UUID_HERE --token YOUR_TOKEN
```

## Options

| Option | Description | Default |
|--------|-------------|---------|
| `<prompt>` | Positional argument — text description of the character | (built-in isekai protagonist prompt) |
| `--token` | Your Neta API token (required) | — |
| `--size` | Output aspect ratio: `portrait` (832×1216), `landscape` (1216×832), `square` (1024×1024), `tall` (704×1408) | `portrait` |
| `--ref` | Reference image UUID for style inheritance | — |

## Output

Returns a direct image URL.

## Token setup

This skill requires a Neta API token. Pass it via the `--token` flag on every invocation:

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

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

```bash
node isekaicharactergenerator.js "your prompt" --token "$NETA_TOKEN"
```

Get a free trial token at <https://www.neta.art/open/>.


FILE:isekaicharactergenerator.js
#!/usr/bin/env node
import { argv, exit, stdout } from 'node:process';

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

const DEFAULT_PROMPT = 'anime style isekai protagonist character, transported to a fantasy other-world, magical sword and ornate armor, vibrant Niji-style colors, dramatic cinematic lighting, light novel cover art composition, detailed face and outfit, full body character design sheet';

function parseArgs(args) {
  let prompt = null;
  let size = 'portrait';
  let tokenFlag = null;
  let ref = null;

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

  return { prompt, size, tokenFlag, ref };
}

async function makeImage({ prompt, size, token, ref }) {
  const dims = SIZES[size] || SIZES.portrait;

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: {
      'x-token': token,
      'x-platform': 'nieta-app/web',
      'content-type': 'application/json',
    },
    body: JSON.stringify(body),
  });

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

  const raw = await res.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(raw);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = raw.trim().replace(/^"|"$/g, '');
  }

  if (!taskUuid) {
    throw new Error(`No task_uuid returned: raw`);
  }

  return taskUuid;
}

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

    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: {
        'x-token': token,
        'x-platform': 'nieta-app/web',
        'content-type': 'application/json',
      },
    });

    if (!res.ok) continue;

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

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

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

    if (url) return url;
    throw new Error(`Task finished but no URL: JSON.stringify(data)`);
  }

  throw new Error('Timed out after 90 polling attempts.');
}

async function main() {
  const { prompt, size, tokenFlag, ref } = parseArgs(argv.slice(2));

  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);
  }

  const finalPrompt = prompt || DEFAULT_PROMPT;

  const taskUuid = await makeImage({ prompt: finalPrompt, size, token: TOKEN, ref });
  const url = await pollTask(taskUuid, TOKEN);
  stdout.write(url + '\n');
  exit(0);
}

main().catch((err) => {
  console.error(`\n✗ err.message`);
  exit(1);
});

FILE:package.json
{"name":"isekai-character-generator","version":"1.0.0","type":"module","description":"Isekai Character Generator — AI-powered isekai character art generator","license":"MIT"}

---
name: pinup-art-generator
description: Generate classic 1950s pin-up art, retro glamour illustrations, vintage poster portraits, mid-century advertising art, and Gil Elvgren style pinup girls. Perfect for Etsy sellers, vintage poster designers, retro merch creators, rockabilly fans, tiki bar decor, and nostalgic 70s/80s aesthetic lovers who want classic pinup portrait illustrations with timeless retro charm via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Pin-Up Art Generator

Generate classic 1950s pin-up art, retro glamour illustrations, vintage poster portraits, mid-century advertising art, and Gil Elvgren style pinup girls. Perfect for Etsy sellers, vintage poster designers, retro merch creators, rockabilly fans, tiki bar decor, and nostalgic 70s/80s aesthetic lovers who want classic pinup portrait illustrations with timeless retro charm.

## 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 pin up art generator images.

## Quick start
```bash
node pinupartgenerator.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/pinup-art-generator
```

FILE:README.md
# Pin-Up Art Generator

Generate classic 1950s pin-up art, retro glamour illustrations, vintage poster portraits, mid-century advertising art, and Gil Elvgren style pinup girls from text descriptions. Perfect for Etsy sellers, vintage poster designers, retro merch creators, rockabilly fans, tiki bar decor, and nostalgic 70s/80s aesthetic lovers who want classic pinup portrait illustrations with timeless retro charm — all generated from a written prompt, no source image needed.

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

## Install

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

Or via ClawHub:

```bash
clawhub install pinup-art-generator
```

## Usage

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

### Examples

Generate with the default pin-up prompt:

```bash
node pinupartgenerator.js "" --token YOUR_TOKEN
```

Custom prompt:

```bash
node pinupartgenerator.js "1950s pin-up girl in red polka dot dress, winking at camera, pastel background" --token YOUR_TOKEN
```

Landscape orientation:

```bash
node pinupartgenerator.js "retro tiki bar pin-up scene, tropical pastel palette" --size landscape --token YOUR_TOKEN
```

Style-inherit from a reference image:

```bash
node pinupartgenerator.js "vintage rockabilly pin-up portrait" --ref <picture_uuid> --token YOUR_TOKEN
```

## Options

| Option | Description | Default |
| --- | --- | --- |
| `<prompt>` | First positional arg — the text description. If empty, a classic pin-up prompt is used. | built-in pin-up prompt |
| `--token` | Your Neta API token (required). | — |
| `--size` | Output aspect ratio: `portrait`, `landscape`, `square`, `tall`. | `portrait` |
| `--ref` | Reference image UUID for style inheritance. | — |

### Size reference

| Size | Dimensions |
| --- | --- |
| `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
```

## Output

Returns a direct image URL printed to stdout on success. Progress messages are printed to stderr so you can pipe the URL cleanly:

```bash
IMG=$(node pinupartgenerator.js "pin-up girl reading a magazine" --token "$NETA_TOKEN")
echo "Generated: $IMG"
```

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

FILE:package.json
{"name":"pinup-art-generator","version":"1.0.0","type":"module","description":"Pin-Up Art Generator — AI-powered pin up art generator","license":"MIT"}

FILE:pinupartgenerator.js
#!/usr/bin/env node
import { argv, exit, stdout } from 'node:process';

const DEFAULT_PROMPT = 'vintage 1950s pin-up art illustration, classic retro glamour pose, stylized lineart with soft shading, warm sepia and pastel palette, mid-century advertising poster aesthetic, playful elegant composition, film grain texture, art by Gil Elvgren';

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

function parseArgs(args) {
  let prompt = null;
  let size = 'portrait';
  let tokenFlag = null;
  let ref = null;

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

  return { prompt, size, tokenFlag, ref };
}

async function main() {
  const { prompt: userPrompt, size, tokenFlag, ref } = parseArgs(argv.slice(2));

  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);
  }

  const PROMPT = userPrompt || DEFAULT_PROMPT;
  const dims = SIZES[size] || SIZES.portrait;

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

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  console.error(`→ Submitting job (dims.width×dims.height)...`);

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

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

  const rawText = await submitRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(rawText);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = rawText.replace(/^"|"$/g, '').trim();
  }

  if (!taskUuid) {
    console.error(`\n✗ No task_uuid in response: rawText`);
    process.exit(1);
  }

  console.error(`→ Task: taskUuid`);
  console.error('→ Polling...');

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

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

    if (!pollRes.ok) {
      continue;
    }

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

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

    const url = (data.artifacts && data.artifacts[0] && data.artifacts[0].url) || data.result_image_url;
    if (url) {
      stdout.write(url + '\n');
      exit(0);
    }

    console.error(`\n✗ Task ended with status "status" but no image URL.`);
    console.error(JSON.stringify(data, null, 2));
    process.exit(1);
  }

  console.error('\n✗ Timed out after 90 attempts (~3 minutes).');
  process.exit(1);
}

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

---
name: retro-travel-poster-generator
description: Generate vintage-style travel posters inspired by the golden age of tourism advertising (1920s-1960s WPA, art deco, mid-century modern) featuring iconic destinations, national parks, beaches, cities, landmarks, and exotic locales. Perfect for Etsy sellers, print-on-demand stores, wall art, home decor, postcards, travel agency branding, Airbnb listings, nostalgic gifts, retro aesthetic collections, and vintage tourism poster prints via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Retro Travel Poster Generator

Generate vintage-style travel posters inspired by the golden age of tourism advertising (1920s-1960s WPA, art deco, mid-century modern) featuring iconic destinations, national parks, beaches, cities, landmarks, and exotic locales. Perfect for Etsy sellers, print-on-demand stores, wall art, home decor, postcards, travel agency branding, Airbnb listings, nostalgic gifts, retro aesthetic collections, and vintage tourism poster prints.

## 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 retro travel poster generator images.

## Quick start
```bash
node retrotravelpostergenerator.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/retro-travel-poster-generator
```

FILE:README.md
# Retro Travel Poster Generator

Generate vintage-style travel posters from text descriptions, inspired by the golden age of tourism advertising (1920s–1960s WPA, art deco, mid-century modern). Describe any destination — national parks, beaches, cities, landmarks, exotic locales — and the skill produces a poster-style illustration with bold flat colors, stylized scenery, screen-printed texture, and nostalgic composition. Ideal for Etsy sellers, print-on-demand stores, wall art, home decor, postcards, travel agency branding, Airbnb listings, and retro aesthetic collections.

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

## Install

```bash
npx skills add blammectrappora/retro-travel-poster-generator
```

Or with ClawHub:

```bash
clawhub install retro-travel-poster-generator
```

## Usage

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

### Examples

```bash
# Classic national park poster
node retrotravelpostergenerator.js "Yosemite Valley at sunset, granite cliffs, pine trees" --token YOUR_TOKEN

# Mid-century beach destination
node retrotravelpostergenerator.js "Santorini coastline, white buildings, blue domes" --size landscape --token YOUR_TOKEN

# City travel poster
node retrotravelpostergenerator.js "Paris Eiffel Tower at dusk, art deco style" --size portrait --token YOUR_TOKEN

# Use a reference image for consistent style
node retrotravelpostergenerator.js "Mount Fuji with cherry blossoms" --ref PICTURE_UUID --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `--size` | Image dimensions: `portrait` (832×1216), `landscape` (1216×832), `square` (1024×1024), `tall` (704×1408) | `portrait` |
| `--token` | Your Neta API token (required) | — |
| `--ref` | Reference image UUID for style inheritance | — |

## 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
```

## Output

Returns a direct image URL.


FILE:package.json
{"name":"retro-travel-poster-generator","version":"1.0.0","type":"module","description":"Retro Travel Poster Generator — AI-powered retro travel poster generator","license":"MIT"}

FILE:retrotravelpostergenerator.js
#!/usr/bin/env node
import { argv, exit, stdout, stderr } from 'node:process';

const DEFAULT_PROMPT = 'vintage retro travel poster illustration, 1950s tourism advertising style, bold flat colors, stylized landmarks and scenery, art deco typography space, screen-printed texture, WPA national park poster aesthetic, golden age of travel, nostalgic composition, clean geometric shapes, muted palette with pops of saturated color';

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

function parseArgs(args) {
  const out = { prompt: null, size: 'portrait', token: null, ref: null };
  const positional = [];
  for (let i = 0; i < args.length; i++) {
    const a = args[i];
    if (a === '--size') { out.size = args[++i]; }
    else if (a === '--token') { out.token = args[++i]; }
    else if (a === '--ref') { out.ref = args[++i]; }
    else if (!a.startsWith('--')) { positional.push(a); }
  }
  if (positional.length > 0) out.prompt = positional.join(' ');
  return out;
}

async function submitTask({ prompt, width, height, token, ref }) {
  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }
  const res = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: {
      'x-token': token,
      'x-platform': 'nieta-app/web',
      'content-type': 'application/json',
    },
    body: JSON.stringify(body),
  });
  if (!res.ok) {
    const text = await res.text();
    throw new Error(`submit failed: res.status text`);
  }
  const ct = res.headers.get('content-type') || '';
  if (ct.includes('application/json')) {
    const data = await res.json();
    if (typeof data === 'string') return data;
    if (data && data.task_uuid) return data.task_uuid;
    throw new Error(`unexpected submit response: JSON.stringify(data)`);
  }
  const text = (await res.text()).trim().replace(/^"|"$/g, '');
  return text;
}

async function pollTask(taskUuid, token) {
  for (let i = 0; i < 90; i++) {
    await new Promise((r) => setTimeout(r, 2000));
    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: {
        'x-token': token,
        'x-platform': 'nieta-app/web',
        'content-type': 'application/json',
      },
    });
    if (!res.ok) continue;
    const data = await res.json();
    const status = data.task_status;
    if (status === 'PENDING' || status === 'MODERATION') continue;
    if (Array.isArray(data.artifacts) && data.artifacts.length > 0 && data.artifacts[0].url) {
      return data.artifacts[0].url;
    }
    if (data.result_image_url) return data.result_image_url;
    throw new Error(`task ended without image: JSON.stringify(data)`);
  }
  throw new Error('timed out after 90 attempts');
}

async function main() {
  const { prompt: promptArg, size, token: tokenFlag, ref } = parseArgs(argv.slice(2));
  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/');
    exit(1);
  }
  const prompt = promptArg || DEFAULT_PROMPT;
  const dims = SIZES[size] || SIZES.portrait;
  stderr.write(`→ Submitting task (dims.width×dims.height)...\n`);
  const taskUuid = await submitTask({ prompt, width: dims.width, height: dims.height, token: TOKEN, ref });
  stderr.write(`→ Task taskUuid, polling...\n`);
  const url = await pollTask(taskUuid, TOKEN);
  stdout.write(url + '\n');
  exit(0);
}

main().catch((err) => {
  console.error(`\n✗ err.message`);
  exit(1);
});

---
name: impressionist-art-generator
description: Generate stunning impressionist-style art in the tradition of Monet, Renoir, Van Gogh, Degas, and Pissarro. Perfect for wall art, Etsy prints, art education, painting references, gallery-style landscapes, garden scenes, plein air portraits, and 19th-century French impressionism aesthetics with soft brushstrokes, pastel palettes, and dappled light via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Impressionist Art Generator

Generate stunning impressionist-style art in the tradition of Monet, Renoir, Van Gogh, Degas, and Pissarro. Perfect for wall art, Etsy prints, art education, painting references, gallery-style landscapes, garden scenes, plein air portraits, and 19th-century French impressionism aesthetics with soft brushstrokes, pastel palettes, and dappled light.

## 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 impressionist art generator images.

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

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

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

FILE:README.md
# Impressionist Art Generator

Generate stunning impressionist-style art from text descriptions in the tradition of Claude Monet, Pierre-Auguste Renoir, Vincent van Gogh, Edgar Degas, and Camille Pissarro. Turn any idea into a gallery-ready painting with soft visible brushstrokes, dappled natural light, pastel palettes with luminous highlights, and the atmospheric feel of late 19th-century French plein air painting — perfect for wall art, Etsy prints, art education, painting references, garden scenes, and portrait studies.

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

## Install

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

Or via ClawHub:

```bash
clawhub install impressionist-art-generator
```

## Usage

```bash
node impressionistartgenerator.js "a quiet water-lily pond at sunrise" --token YOUR_TOKEN
```

### Examples

Landscape (default):

```bash
node impressionistartgenerator.js "a field of poppies under a breezy summer sky" --token YOUR_TOKEN
```

Portrait orientation:

```bash
node impressionistartgenerator.js "a young woman reading in a sunlit garden" --size portrait --token YOUR_TOKEN
```

Square for social posts:

```bash
node impressionistartgenerator.js "a Paris café terrace in the afternoon" --size square --token YOUR_TOKEN
```

Inherit style from a reference picture:

```bash
node impressionistartgenerator.js "cliffs overlooking the sea at Étretat" --ref <picture_uuid> --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `--token` | Your Neta API token (required) | — |
| `--size` | `portrait` (832×1216), `landscape` (1216×832), `square` (1024×1024), `tall` (704×1408) | `landscape` |
| `--ref` | Reference image UUID for style inheritance | — |

## Output

Returns a direct image URL.

## Token setup

You need a Neta API token to use this skill. Grab a free trial token at <https://www.neta.art/open/>.

Pass your token on every run using the `--token` flag:

```bash
node impressionistartgenerator.js "your prompt here" --token YOUR_TOKEN
```

You can also expand a shell variable yourself if you prefer:

```bash
node impressionistartgenerator.js "your prompt here" --token "$NETA_TOKEN"
```

The `--token` flag is the only way this script accepts a token.

---

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

FILE:impressionistartgenerator.js
#!/usr/bin/env node
import process from 'node:process';

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

const DEFAULT_PROMPT_PREFIX = "impressionist oil painting in the style of Claude Monet and Pierre-Auguste Renoir, soft visible brushstrokes, dappled natural light, pastel palette with luminous highlights, atmospheric plein air scene, textured canvas feel, late 19th century French impressionism";

function parseArgs(argv) {
  const args = { positional: [], size: 'landscape', token: null, ref: null };
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (a === '--size') { args.size = argv[++i]; }
    else if (a === '--token') { args.token = argv[++i]; }
    else if (a === '--ref') { args.ref = argv[++i]; }
    else if (a.startsWith('--size=')) { args.size = a.slice(7); }
    else if (a.startsWith('--token=')) { args.token = a.slice(8); }
    else if (a.startsWith('--ref=')) { args.ref = a.slice(6); }
    else { args.positional.push(a); }
  }
  return args;
}

async function main() {
  const args = parseArgs(process.argv.slice(2));
  const userPrompt = args.positional.join(' ').trim();

  if (!userPrompt) {
    console.error('\n✗ Prompt required. Usage: node impressionistartgenerator.js "your prompt" --token YOUR_TOKEN');
    process.exit(1);
  }

  const tokenFlag = args.token;
  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);
  }

  const size = SIZES[args.size] || SIZES.landscape;
  const PROMPT = `DEFAULT_PROMPT_PREFIX, userPrompt`;

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

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

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

  console.error(`→ Submitting task (size.width×size.height)...`);

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

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

  const raw = await submitRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(raw);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = raw.replace(/^"|"$/g, '').trim();
  }

  if (!taskUuid) {
    console.error('\n✗ No task_uuid returned');
    process.exit(1);
  }

  console.error(`→ Task taskUuid submitted. Polling...`);

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

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

    if (!pollRes.ok) {
      console.error(`  poll attempt + 1: HTTP pollRes.status`);
      continue;
    }

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

    if (status === 'PENDING' || status === 'MODERATION') {
      if (attempt % 5 === 0) console.error(`  poll attempt + 1: status`);
      continue;
    }

    const url =
      (Array.isArray(data.artifacts) && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;

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

    console.error(`\n✗ Task ended with status=status but no URL found`);
    console.error(JSON.stringify(data, null, 2));
    process.exit(1);
  }

  console.error('\n✗ Timed out waiting for task to complete');
  process.exit(1);
}

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

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

---
name: ghost-portrait-generator
description: Generate haunting ghost portraits and inner demon shadow photos with AI — create spectral ghostly apparitions, paranormal spirit figures, smoky shadow companions standing behind subjects, translucent ethereal ghosts, gothic horror portraits, Halloween spooky imagery, dark supernatural aesthetic art, ghostly phantom visuals, and eerie spectre illustrations perfect for social media viral trends, Halloween content, horror story covers, gothic aesthetic feeds, paranormal enthusiasts, dark fantasy art, and spooky photo transformations inspired by the viral Gemini and ChatGPT ghost portrait trend via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Ghost Portrait Generator

Generate haunting ghost portraits and inner demon shadow photos with AI — create spectral ghostly apparitions, paranormal spirit figures, smoky shadow companions standing behind subjects, translucent ethereal ghosts, gothic horror portraits, Halloween spooky imagery, dark supernatural aesthetic art, ghostly phantom visuals, and eerie spectre illustrations perfect for social media viral trends, Halloween content, horror story covers, gothic aesthetic feeds, paranormal enthusiasts, dark fantasy art, and spooky photo transformations inspired by the viral Gemini and ChatGPT ghost portrait trend.

## 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 ghost portrait ai generator images.

## Quick start
```bash
node ghostportraitgenerator.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/ghost-portrait-generator
```

FILE:README.md
# Ghost Portrait Generator

Generate haunting ghost portraits and spectral apparition images from text descriptions. Describe the ghost, mood, era, attire, and atmosphere you want, and this skill produces a cinematic, photorealistic ghost portrait — perfect for Halloween content, gothic aesthetic feeds, horror story covers, and the viral ghost portrait trend popularized on social media.

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

## Install

```bash
npx skills add blammectrappora/ghost-portrait-generator
```

Or via ClawHub:

```bash
clawhub install ghost-portrait-generator
```

## Usage

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

### Examples

Generate a default ghost portrait:

```bash
node ghostportraitgenerator.js "a translucent Victorian ghost in a candlelit hallway, torn lace gown, pale glowing skin, eerie fog" --token YOUR_TOKEN
```

Landscape orientation:

```bash
node ghostportraitgenerator.js "spectral figure drifting over a misty graveyard at midnight, full moon, cinematic horror lighting" --size landscape --token YOUR_TOKEN
```

With a reference image UUID for style inheritance:

```bash
node ghostportraitgenerator.js "a shadowy phantom behind a lone traveler, wisps of smoke, gothic horror" --ref 123e4567-e89b-12d3-a456-426614174000 --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| (positional) | Text prompt describing the ghost portrait | built-in haunting prompt |
| `--size` | Image size: `portrait`, `landscape`, `square`, `tall` | `portrait` |
| `--token` | Neta API token | *required* |
| `--ref` | Reference image UUID for style inheritance | none |

### Sizes

- `portrait` — 832×1216
- `landscape` — 1216×832
- `square` — 1024×1024
- `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
```

## Output

Returns a direct image URL.


FILE:ghostportraitgenerator.js
#!/usr/bin/env node
import process from 'node:process';

const DEFAULT_PROMPT = 'A haunting ghost portrait featuring a translucent spectral figure with ethereal mist, dark atmospheric shadows, dim moonlight, wispy smoke curling around the figure, pale glowing skin, empty hollow eyes, vintage gothic attire with tattered fabric, eerie fog rolling in the background, cinematic horror lighting, supernatural paranormal aesthetic, dramatic chiaroscuro, high contrast dark moody atmosphere, photorealistic spooky ghostly apparition';

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

function parseArgs(argv) {
  const args = argv.slice(2);
  let prompt = null;
  let size = 'portrait';
  let tokenFlag = null;
  let ref = null;

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

  return { prompt, size, tokenFlag, ref };
}

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

async function main() {
  const { prompt: promptArg, size, tokenFlag, ref } = parseArgs(process.argv);

  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);
  }

  const PROMPT = promptArg || DEFAULT_PROMPT;
  const dims = SIZES[size] || SIZES.portrait;

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

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

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

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

  const submitBody = await submitRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(submitBody);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = submitBody.replace(/^"|"$/g, '').trim();
  }

  if (!taskUuid) {
    console.error('\n✗ No task_uuid in response');
    process.exit(1);
  }

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

    if (!pollRes.ok) {
      continue;
    }

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

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

    const url =
      (Array.isArray(data.artifacts) && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;

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

    console.error(`\n✗ Task finished with status status but no image URL`);
    process.exit(1);
  }

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

main().catch((err) => {
  console.error(`\n✗ err.message || err`);
  process.exit(1);
});

FILE:package.json
{"name":"ghost-portrait-generator","version":"1.0.0","type":"module","description":"Ghost Portrait Generator — AI-powered ghost portrait ai generator","license":"MIT"}

---
name: noir-photo-generator
description: Generate dramatic film noir style portraits and scenes with AI. Perfect for creating 1940s detective aesthetic photos, black and white cinematic portraits, vintage crime fiction artwork, moody atmospheric shots with venetian blind shadows, rain-soaked streets, and classic Hollywood noir vibes for social media, book covers, posters, and creative projects via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Film Noir Photo Generator

Generate dramatic film noir style portraits and scenes with AI. Perfect for creating 1940s detective aesthetic photos, black and white cinematic portraits, vintage crime fiction artwork, moody atmospheric shots with venetian blind shadows, rain-soaked streets, and classic Hollywood noir vibes for social media, book covers, posters, and creative projects.

## 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 film noir photo generator images.

## Quick start
```bash
node noirphotogenerator.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/noir-photo-generator
```

FILE:README.md
# Film Noir Photo Generator

Generate dramatic film noir style images from text descriptions. Create 1940s detective aesthetic portraits, black and white cinematic scenes, vintage crime fiction artwork, and moody atmospheric shots with venetian blind shadows, rain-soaked streets, and classic Hollywood noir vibes — all from a single text prompt.

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

## Install

Via ClawHub/OpenClaw:

```bash
npx skills add blammectrappora/noir-photo-generator
```

Or:

```bash
clawhub install noir-photo-generator
```

## Usage

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

### Examples

Generate a default film noir portrait:

```bash
node noirphotogenerator.js "detective in a trench coat under a streetlamp" --token YOUR_TOKEN
```

Landscape scene:

```bash
node noirphotogenerator.js "rainy alley with neon signs, 1940s city street" --size landscape --token YOUR_TOKEN
```

Style inheritance from a reference image:

```bash
node noirphotogenerator.js "smoky jazz club interior" --ref <picture_uuid> --token YOUR_TOKEN
```

## Options

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

### Size dimensions

| Size | Dimensions |
| --- | --- |
| `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
```

## Output

Returns a direct image URL.


FILE:noirphotogenerator.js
#!/usr/bin/env node
import process from 'node:process';

const DEFAULT_PROMPT = "film noir portrait, dramatic high-contrast black and white, venetian blind shadows, cigarette smoke, rain-soaked street, vintage 1940s detective aesthetic, cinematic lighting, grainy film texture, moody atmosphere";

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

function parseArgs(argv) {
  const args = { size: 'portrait', prompt: null, token: null, ref: null };
  const rest = argv.slice(2);
  for (let i = 0; i < rest.length; i++) {
    const a = rest[i];
    if (a === '--size') {
      args.size = rest[++i];
    } else if (a === '--token') {
      args.token = rest[++i];
    } else if (a === '--ref') {
      args.ref = rest[++i];
    } else if (!a.startsWith('--') && args.prompt === null) {
      args.prompt = a;
    }
  }
  return args;
}

async function main() {
  const { prompt: promptArg, size, token: tokenFlag, ref } = parseArgs(process.argv);

  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);
  }

  const PROMPT = promptArg || DEFAULT_PROMPT;
  const dims = SIZES[size] || SIZES.portrait;

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

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  console.error(`→ Generating film noir image (dims.width×dims.height)...`);

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

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

  const submitText = await submitRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(submitText);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = submitText.replace(/^"|"$/g, '').trim();
  }

  if (!taskUuid) {
    console.error('✗ No task_uuid returned');
    process.exit(1);
  }

  console.error(`→ Task: taskUuid`);

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

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

    if (!pollRes.ok) {
      continue;
    }

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

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

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

    const url = (data.artifacts && data.artifacts[0] && data.artifacts[0].url) || data.result_image_url;
    if (url) {
      console.log(url);
      process.exit(0);
    }

    console.error(`✗ Task ended with status "status" but no image URL`);
    process.exit(1);
  }

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

main().catch((err) => {
  console.error(`✗ err.message`);
  process.exit(1);
});

FILE:package.json
{"name":"noir-photo-generator","version":"1.0.0","type":"module","description":"Film Noir Photo Generator — AI-powered film noir photo generator","license":"MIT"}

---
name: chinese-ink-painting-generator
description: Generate stunning traditional Chinese ink paintings (shui-mo hua) and sumi-e brushwork art with AI. Create classical shan shui landscapes, bamboo, koi, dragons, plum blossoms, calligraphy art, oriental scrolls, Japanese ink wash, zen minimalist art, and East Asian brush painting illustrations for wallpapers, prints, tea house decor, meditation art, cultural projects, and traditional aesthetic designs via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Chinese Ink Painting Generator

Generate stunning traditional Chinese ink paintings (shui-mo hua) and sumi-e brushwork art with AI. Create classical shan shui landscapes, bamboo, koi, dragons, plum blossoms, calligraphy art, oriental scrolls, Japanese ink wash, zen minimalist art, and East Asian brush painting illustrations for wallpapers, prints, tea house decor, meditation art, cultural projects, and traditional aesthetic designs.

## 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 chinese ink painting generator images.

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

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

## Install
```bash
npx skills add blammectrappora/chinese-ink-painting-generator
```

FILE:README.md
# Chinese Ink Painting Generator

Generate stunning traditional Chinese ink paintings (shui-mo hua) and sumi-e brushwork art from text descriptions. Create classical shan shui landscapes, bamboo, koi, dragons, plum blossoms, calligraphy art, oriental scrolls, Japanese ink wash, zen minimalist art, and East Asian brush painting illustrations for wallpapers, prints, tea house decor, meditation art, cultural projects, and traditional aesthetic designs — all from a short prompt.

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

## Install

```bash
npx skills add blammectrappora/chinese-ink-painting-generator
```

Or with ClawHub:

```bash
clawhub install chinese-ink-painting-generator
```

## Usage

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

### Examples

```bash
# Default landscape shan shui scene
node chineseinkpaintinggenerator.js "misty mountains with a lone fisherman on a bamboo raft" --token YOUR_TOKEN

# Vertical hanging-scroll portrait
node chineseinkpaintinggenerator.js "plum blossoms on a twisted branch, single magpie" --size portrait --token YOUR_TOKEN

# Square composition of koi fish
node chineseinkpaintinggenerator.js "two koi fish swirling in rippling water, sumi-e style" --size square --token YOUR_TOKEN

# Inherit style from a reference image
node chineseinkpaintinggenerator.js "wandering monk crossing a stone bridge" --ref PICTURE_UUID --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `--size` | Aspect ratio: `portrait` (832×1216), `landscape` (1216×832), `square` (1024×1024), `tall` (704×1408) | `landscape` |
| `--token` | Neta API token (required) | — |
| `--ref` | Reference image UUID for style inheritance | — |

## Output

Returns a direct image URL.

## Token Setup

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

Pass the token with the `--token` flag every time you invoke the script:

```bash
node chineseinkpaintinggenerator.js "ancient pine tree on a cliff" --token YOUR_TOKEN
```

You can keep your token in a shell variable and expand it at call time:

```bash
node chineseinkpaintinggenerator.js "cranes flying over a lake at dawn" --token "$NETA_TOKEN"
```

The `--token` flag is the only way the script accepts a token.


FILE:chineseinkpaintinggenerator.js
#!/usr/bin/env node
import { argv, exit, stdout, stderr } from 'node:process';

const DEFAULT_PROMPT = "traditional Chinese ink painting (shui-mo hua), sumi-e brushwork, flowing black ink on rice paper, misty mountains and bamboo, minimalist negative space composition, delicate calligraphic strokes, soft gradient washes, serene oriental aesthetic, classic shan shui landscape style";

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

function parseArgs(args) {
  let prompt = null;
  let size = 'landscape';
  let tokenFlag = null;
  let ref = null;

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

  return { prompt, size, tokenFlag, ref };
}

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

async function main() {
  const { prompt, size, tokenFlag, ref } = parseArgs(argv.slice(2));

  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);
  }

  const PROMPT = prompt || DEFAULT_PROMPT;

  const dims = SIZES[size];
  if (!dims) {
    stderr.write(`\n✗ Invalid size: size. Must be one of: Object.keys(SIZES).join(', ')\n`);
    exit(1);
  }

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

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  stderr.write(`Generating: "PROMPT"\n`);
  stderr.write(`Size: size (dims.widthxdims.height)\n`);

  let submitRes;
  try {
    submitRes = await fetch('https://api.talesofai.com/v3/make_image', {
      method: 'POST',
      headers,
      body: JSON.stringify(body),
    });
  } catch (err) {
    stderr.write(`\n✗ Request failed: err.message\n`);
    exit(1);
  }

  if (!submitRes.ok) {
    const text = await submitRes.text();
    stderr.write(`\n✗ API error submitRes.status: text\n`);
    exit(1);
  }

  const submitText = await submitRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(submitText);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = submitText.trim().replace(/^"|"$/g, '');
  }

  if (!taskUuid) {
    stderr.write(`\n✗ No task_uuid returned: submitText\n`);
    exit(1);
  }

  stderr.write(`Task: taskUuid\nPolling...\n`);

  for (let attempt = 0; attempt < 90; attempt++) {
    await sleep(2000);
    let pollRes;
    try {
      pollRes = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
        headers,
      });
    } catch (err) {
      stderr.write(`  poll error: err.message\n`);
      continue;
    }

    if (!pollRes.ok) {
      stderr.write(`  poll pollRes.status\n`);
      continue;
    }

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

    if (status === 'PENDING' || status === 'MODERATION') {
      stderr.write(`  status... (attempt + 1/90)\n`);
      continue;
    }

    const url = (data.artifacts && data.artifacts[0] && data.artifacts[0].url) || data.result_image_url;
    if (url) {
      stdout.write(url + '\n');
      exit(0);
    }

    stderr.write(`\n✗ Task ended with status "status" but no image URL.\n`);
    stderr.write(JSON.stringify(data, null, 2) + '\n');
    exit(1);
  }

  stderr.write('\n✗ Timed out after 90 attempts (~3 minutes).\n');
  exit(1);
}

main().catch((err) => {
  stderr.write(`\n✗ err.message\n`);
  exit(1);
});

FILE:package.json
{"name":"chinese-ink-painting-generator","version":"1.0.0","type":"module","description":"Chinese Ink Painting Generator — AI-powered chinese ink painting generator","license":"MIT"}

---
name: baroque-art-generator
description: any subject into dramatic baroque oil painting art with rich chiaroscuro lighting, opulent Caravaggio and Rembrandt style textures, and classical Renaissance composition. Perfect for creating baroque portraits, classical art prints, museum-style oil paintings, Renaissance-inspired wall art, old masters style portraits, and ornate historical artwork for Etsy sellers, art collectors, and classical aesthetic lovers via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Baroque Art Generator

any subject into dramatic baroque oil painting art with rich chiaroscuro lighting, opulent Caravaggio and Rembrandt style textures, and classical Renaissance composition. Perfect for creating baroque portraits, classical art prints, museum-style oil paintings, Renaissance-inspired wall art, old masters style portraits, and ornate historical artwork for Etsy sellers, art collectors, and classical aesthetic 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 baroque art generator images.

## Quick start
```bash
node baroqueartgenerator.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/baroque-art-generator
```

FILE:README.md
# Baroque Art Generator

Generate dramatic baroque oil painting images from text descriptions — rich chiaroscuro lighting, opulent Caravaggio and Rembrandt style textures, and classical Renaissance composition. Ideal for baroque portraits, classical art prints, museum-style oil paintings, Renaissance-inspired wall art, old masters portraits, and ornate historical artwork.

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

## Install

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

Or with ClawHub:

```bash
clawhub install baroque-art-generator
```

## Usage

```bash
node baroqueartgenerator.js "a regal queen holding a golden chalice" --token YOUR_TOKEN
```

Generate with a custom size:

```bash
node baroqueartgenerator.js "a contemplative scholar by candlelight" --size portrait --token YOUR_TOKEN
```

Inherit style from a reference image:

```bash
node baroqueartgenerator.js "a warrior in ornate armor" --ref <picture_uuid> --token YOUR_TOKEN
```

Returns a direct image URL.

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `<prompt>` | First positional argument — text description of the image | Built-in baroque prompt |
| `--size` | Output size: `portrait`, `landscape`, `square`, `tall` | `portrait` |
| `--token` | Neta API token (required) | — |
| `--ref` | Reference image UUID for style inheritance | — |

### Sizes

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

## Token setup

Pass your Neta API token via the `--token` flag on every call:

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

You can keep the token in a shell variable and expand it inline:

```bash
node baroqueartgenerator.js "your prompt" --token "$NETA_TOKEN"
```

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

FILE:baroqueartgenerator.js
#!/usr/bin/env node
import process from 'node:process';

const DEFAULT_PROMPT = 'baroque oil painting masterpiece, dramatic chiaroscuro lighting, rich golden and deep crimson color palette, ornate renaissance composition, painterly brushstrokes, opulent fabric textures, museum-quality classical portrait in the style of Caravaggio and Rembrandt, dramatic shadow play, gilded details';

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

function parseArgs(argv) {
  const args = { size: 'portrait', token: null, ref: null, prompt: null };
  const rest = [];
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (a === '--size') args.size = argv[++i];
    else if (a === '--token') args.token = argv[++i];
    else if (a === '--ref') args.ref = argv[++i];
    else rest.push(a);
  }
  if (rest.length > 0) args.prompt = rest.join(' ');
  return args;
}

async function main() {
  const { size, token: tokenFlag, ref, prompt } = parseArgs(process.argv.slice(2));

  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);
  }

  const PROMPT = prompt || DEFAULT_PROMPT;
  const dims = SIZES[size] || SIZES.portrait;

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

  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  console.error(`→ Submitting: "PROMPT.slice(0, 80)''"`);
  console.error(`  Size: size (dims.width×dims.height)`);

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

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

  const submitText = await submitRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(submitText);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = submitText.replace(/^"|"$/g, '').trim();
  }

  if (!taskUuid) {
    console.error('✗ No task_uuid returned');
    process.exit(1);
  }

  console.error(`  Task: taskUuid`);
  console.error('→ Polling…');

  for (let attempt = 0; attempt < 90; attempt++) {
    await new Promise((r) => setTimeout(r, 2000));
    const pollRes = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, { headers });
    if (!pollRes.ok) continue;
    const data = await pollRes.json();
    const status = data.task_status;
    if (status === 'PENDING' || status === 'MODERATION') continue;
    const url = data.artifacts?.[0]?.url || data.result_image_url;
    if (url) {
      console.log(url);
      process.exit(0);
    }
    console.error(`✗ Task finished with status status but no URL`);
    process.exit(1);
  }

  console.error('✗ Timed out after 90 attempts');
  process.exit(1);
}

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

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

---
name: mascot-generator
description: Generate custom brand mascots and cartoon characters with AI. Perfect for small businesses, startups, sports teams, schools, gaming clans, esports crews, and YouTube channels that need a unique company mascot, brand character, cute logo mascot, team figure, or memorable brand identity illustration via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Mascot Generator

Generate custom brand mascots and cartoon characters with AI. Perfect for small businesses, startups, sports teams, schools, gaming clans, esports crews, and YouTube channels that need a unique company mascot, brand character, cute logo mascot, team figure, or memorable brand identity illustration.

## 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 brand mascot generator images.

## Quick start
```bash
node mascotgenerator.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/mascot-generator
```

FILE:README.md
# Mascot Generator

Generate custom brand mascots and cartoon characters from text descriptions using AI. Perfect for small businesses, startups, sports teams, schools, gaming clans, esports crews, and YouTube channels that need a unique company mascot, brand character, cute logo mascot, team figure, or memorable brand identity illustration — all created from a simple written prompt.

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

## Install

Using the ClawHub skills CLI:

```bash
npx skills add blammectrappora/mascot-generator
```

Or using clawhub directly:

```bash
clawhub install mascot-generator
```

## Usage

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

### Examples

Generate a coffee shop mascot:

```bash
node mascotgenerator.js "a smiling coffee bean character wearing a barista apron, holding a tiny cup" --token YOUR_TOKEN
```

Generate an esports team mascot in landscape:

```bash
node mascotgenerator.js "fierce wolf mascot for an esports team, wearing headphones, neon accents" \
  --token YOUR_TOKEN \
  --size landscape
```

Use a reference image UUID for style inheritance:

```bash
node mascotgenerator.js "friendly robot mascot for a tech startup" \
  --token YOUR_TOKEN \
  --ref 123e4567-e89b-12d3-a456-426614174000
```

## Options

| Flag       | Description                                                       | Default  |
| ---------- | ----------------------------------------------------------------- | -------- |
| `--token`  | Neta API token (required)                                         | —        |
| `--size`   | Output aspect: `square`, `portrait`, `landscape`, `tall`          | `square` |
| `--ref`    | Reference image UUID for style inheritance                        | —        |
| `-h`, `--help` | Show help                                                     | —        |

### Sizes

| Name        | Dimensions   |
| ----------- | ------------ |
| `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
```

## Output

Returns a direct image URL.


FILE:mascotgenerator.js
#!/usr/bin/env node
import process from 'node:process';

const DEFAULT_PROMPT = 'cute friendly brand mascot character, full body pose, clean bold outlines, vibrant colors, professional mascot design, commercial character art, memorable and expressive, centered composition, plain background';
const STYLE = 'cinematic';

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

const API_BASE = 'https://api.talesofai.com';

function parseArgs(argv) {
  const args = { _: [] };
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (a === '--size') args.size = argv[++i];
    else if (a === '--token') args.token = argv[++i];
    else if (a === '--ref') args.ref = argv[++i];
    else if (a === '--help' || a === '-h') args.help = true;
    else args._.push(a);
  }
  return args;
}

function printHelp() {
  console.log(`Mascot Generator

Usage:
  node mascotgenerator.js "your prompt" --token YOUR_TOKEN [options]

Options:
  --size <size>   square (default), portrait, landscape, tall
  --token <tok>   Neta API token (required) — get one at https://www.neta.art/open/
  --ref <uuid>    Reference image UUID for style inheritance
  -h, --help      Show this help
`);
}

async function main() {
  const args = parseArgs(process.argv.slice(2));
  if (args.help) {
    printHelp();
    process.exit(0);
  }

  const userPrompt = args._[0];
  const PROMPT = userPrompt && userPrompt.trim().length > 0
    ? `userPrompt.trim(), DEFAULT_PROMPT`
    : DEFAULT_PROMPT;

  const tokenFlag = args.token;
  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);
  }

  const sizeKey = (args.size || 'square').toLowerCase();
  const size = SIZES[sizeKey];
  if (!size) {
    console.error(`✗ Invalid size "sizeKey". Valid: Object.keys(SIZES).join(', ')`);
    process.exit(1);
  }

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

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

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

  console.error(`→ Submitting mascot generation request (size.width×size.height, style: STYLE)...`);

  let submitRes;
  try {
    submitRes = await fetch(`https://api.talesofai.com/v3/make_image`, {
      method: 'POST',
      headers,
      body: JSON.stringify(body),
    });
  } catch (err) {
    console.error(`✗ Network error: err.message`);
    process.exit(1);
  }

  if (!submitRes.ok) {
    const text = await submitRes.text().catch(() => '');
    console.error(`✗ Submit failed (submitRes.status): text`);
    process.exit(1);
  }

  const submitText = await submitRes.text();
  let taskUuid;
  const trimmed = submitText.trim();
  try {
    const parsed = JSON.parse(trimmed);
    if (typeof parsed === 'string') taskUuid = parsed;
    else if (parsed && typeof parsed === 'object') taskUuid = parsed.task_uuid || parsed.taskUuid;
  } catch {
    taskUuid = trimmed.replace(/^"|"$/g, '');
  }

  if (!taskUuid) {
    console.error(`✗ Could not parse task_uuid from response: submitText`);
    process.exit(1);
  }

  console.error(`→ Task submitted: taskUuid`);
  console.error('→ Polling for result...');

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

    let pollRes;
    try {
      pollRes = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, { headers });
    } catch (err) {
      console.error(`  (attempt attempt) network error: err.message`);
      continue;
    }

    if (!pollRes.ok) {
      console.error(`  (attempt attempt) poll failed: pollRes.status`);
      continue;
    }

    let data;
    try {
      data = await pollRes.json();
    } catch {
      continue;
    }

    const status = data.task_status;
    if (status === 'PENDING' || status === 'MODERATION') {
      if (attempt % 5 === 0) console.error(`  ...still status.toLowerCase() (attempt/maxAttempts)`);
      continue;
    }

    const url = (data.artifacts && data.artifacts[0] && data.artifacts[0].url) || data.result_image_url;
    if (url) {
      console.log(url);
      process.exit(0);
    }

    console.error(`✗ Task finished with status "status" but no image URL found.`);
    console.error(JSON.stringify(data, null, 2));
    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);
});

FILE:package.json
{"name":"mascot-generator","version":"1.0.0","type":"module","description":"Mascot Generator — AI-powered brand mascot generator ai","license":"MIT"}

---
name: pet-memorial-portrait-generator
description: Create heartfelt pet memorial portraits and remembrance keepsakes for dogs, cats, and beloved animals who have passed. AI-generated pet memorial art, rainbow bridge portraits, angel pet paintings, and tribute photos perfect for memorial gifts, sympathy cards, keepsake prints, and honoring the memory of a cherished furry family member via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Pet Memorial Portrait Generator

Create heartfelt pet memorial portraits and remembrance keepsakes for dogs, cats, and beloved animals who have passed. AI-generated pet memorial art, rainbow bridge portraits, angel pet paintings, and tribute photos perfect for memorial gifts, sympathy cards, keepsake prints, and honoring the memory of a cherished furry family member.

## 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 pet memorial portrait images.

## Quick start
```bash
node petmemorialportraitgenerator.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-memorial-portrait-generator
```

FILE:README.md
# Pet Memorial Portrait Generator

Create heartfelt pet memorial portraits and remembrance keepsakes from text descriptions. Generate AI pet memorial art, rainbow bridge portraits, angel pet paintings, and tribute imagery perfect for memorial gifts, sympathy cards, keepsake prints, and honoring the memory of a cherished furry family member — all from a written prompt describing the pet you wish to remember.

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

## Install

Via the skills CLI:

```bash
npx skills add blammectrappora/pet-memorial-portrait-generator
```

Or via ClawHub:

```bash
clawhub install pet-memorial-portrait-generator
```

## Usage

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

### Examples

Generate a default memorial portrait:

```bash
node petmemorialportraitgenerator.js "" --token YOUR_TOKEN
```

Custom remembrance scene:

```bash
node petmemorialportraitgenerator.js \
  "golden retriever with angel wings resting in a sunlit meadow, soft cinematic light, peaceful tribute" \
  --token YOUR_TOKEN
```

Landscape orientation for a keepsake card:

```bash
node petmemorialportraitgenerator.js \
  "tabby cat curled on a cloud, gentle starlight, rainbow bridge background" \
  --size landscape \
  --token YOUR_TOKEN
```

Use a reference image for style inheritance:

```bash
node petmemorialportraitgenerator.js \
  "a beloved beagle in a serene garden of remembrance" \
  --ref <picture_uuid> \
  --token YOUR_TOKEN
```

## Options

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

### Sizes

| Size      | Dimensions  |
| --------- | ----------- |
| portrait  | 832 × 1216  |
| landscape | 1216 × 832  |
| square    | 1024 × 1024 |
| 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
```

## Output

Returns a direct image URL.


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

FILE:petmemorialportraitgenerator.js
#!/usr/bin/env node
import process from 'node:process';

const DEFAULT_PROMPT = "A serene memorial portrait of a beloved pet, soft golden light streaming from above, peaceful meadow background with gentle clouds, tender cinematic atmosphere, warm nostalgic tones, detailed fur texture, gentle eyes full of love, tasteful remembrance composition, professional pet photography, soft bokeh, dreamy celestial mood";

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

function parseArgs(argv) {
  const args = { size: 'portrait', token: null, ref: null, prompt: null };
  const rest = argv.slice(2);
  for (let i = 0; i < rest.length; i++) {
    const a = rest[i];
    if (a === '--size')        args.size  = rest[++i];
    else if (a === '--token')  args.token = rest[++i];
    else if (a === '--ref')    args.ref   = rest[++i];
    else if (!args.prompt)     args.prompt = a;
  }
  return args;
}

async function makeImage({ token, prompt, size, ref }) {
  const dims = SIZES[size] || SIZES.portrait;
  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: {
      "x-token": token,
      "x-platform": "nieta-app/web",
      "content-type": "application/json",
    },
    body: JSON.stringify(body),
  });

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

  const ct = res.headers.get("content-type") || "";
  if (ct.includes("application/json")) {
    const data = await res.json();
    if (typeof data === "string") return data;
    if (data && data.task_uuid) return data.task_uuid;
    throw new Error(`Unexpected response: JSON.stringify(data)`);
  }
  const txt = (await res.text()).trim().replace(/^"|"$/g, "");
  return txt;
}

async function pollTask({ token, taskUuid }) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  for (let i = 0; i < 90; i++) {
    const res = await fetch(url, {
      headers: {
        "x-token": token,
        "x-platform": "nieta-app/web",
        "content-type": "application/json",
      },
    });
    if (!res.ok) {
      const txt = await res.text();
      throw new Error(`poll failed: res.status txt`);
    }
    const data = await res.json();
    const status = data.task_status;
    if (status !== "PENDING" && status !== "MODERATION") {
      const url0 = (data.artifacts && data.artifacts[0] && data.artifacts[0].url) || data.result_image_url;
      if (!url0) throw new Error(`Task finished but no image URL: JSON.stringify(data)`);
      return url0;
    }
    await new Promise(r => setTimeout(r, 2000));
  }
  throw new Error("Timed out waiting for task to finish");
}

async function main() {
  const { prompt: promptArg, size, token: tokenFlag, ref } = parseArgs(process.argv);
  const PROMPT = promptArg || DEFAULT_PROMPT;
  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);
  }

  try {
    const taskUuid = await makeImage({ token: TOKEN, prompt: PROMPT, size, ref });
    const imageUrl = await pollTask({ token: TOKEN, taskUuid });
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error(`\n✗ err.message`);
    process.exit(1);
  }
}

main();

---
name: manga-panel-generator
description: Generate professional black-and-white manga panels and comic pages with dynamic poses, screentones, and authentic Japanese manga art style. Perfect for manga artists, doujinshi creators, webtoon storyboards, comic writers, and anime fans who want to illustrate scenes, action sequences, or character moments in classic shonen, shojo, or seinen manga aesthetics via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Manga Panel Generator

Generate professional black-and-white manga panels and comic pages with dynamic poses, screentones, and authentic Japanese manga art style. Perfect for manga artists, doujinshi creators, webtoon storyboards, comic writers, and anime fans who want to illustrate scenes, action sequences, or character moments in classic shonen, shojo, or seinen manga aesthetics.

## 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 manga panel generator images.

## Quick start
```bash
node mangapanelgenerator.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/manga-panel-generator
```

FILE:README.md
# Manga Panel Generator

Generate professional black-and-white manga panels and full comic pages from text descriptions — complete with dynamic poses, screentone shading, expressive action lines, and authentic Japanese manga art style. Ideal for manga artists, doujinshi creators, webtoon storyboarders, comic writers, and anime fans who want to illustrate scenes, action sequences, or character moments in classic shonen, shojo, or seinen aesthetics directly from a written prompt.

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

## Install

With ClawHub:

```bash
npx skills add blammectrappora/manga-panel-generator
```

Or via the ClawHub CLI:

```bash
clawhub install manga-panel-generator
```

## Usage

```bash
node mangapanelgenerator.js "your manga scene description" --token YOUR_TOKEN
```

### Examples

Generate a default manga panel:

```bash
node mangapanelgenerator.js "a young swordsman leaping through the air, sword mid-swing, wind lines swirling" --token YOUR_TOKEN
```

Generate a landscape panel with a reference image:

```bash
node mangapanelgenerator.js "two rivals facing off on a rooftop at sunset" \
  --size landscape \
  --ref 123e4567-e89b-12d3-a456-426614174000 \
  --token YOUR_TOKEN
```

Generate a tall vertical webtoon-style panel:

```bash
node mangapanelgenerator.js "school girl looking out a classroom window, cherry blossoms falling" \
  --size tall \
  --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
|------|-------------|---------|
| (positional) | Prompt describing the manga panel to generate | Built-in manga panel prompt |
| `--size` | Output size: `portrait` (832×1216), `landscape` (1216×832), `square` (1024×1024), `tall` (704×1408) | `portrait` |
| `--token` | Neta API token (required) | — |
| `--ref` | Reference image UUID for style inheritance | — |

## Output

Returns a direct image URL.

## Token setup

This skill requires a Neta API token. Pass it on the command line with the `--token` flag:

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

You can also expand a shell variable into the flag:

```bash
node mangapanelgenerator.js "your prompt" --token "$NETA_TOKEN"
```

Get a free trial token at <https://www.neta.art/open/>.


FILE:mangapanelgenerator.js
#!/usr/bin/env node
// Manga Panel Generator — generate manga panels via Neta AI image generation API.

const DEFAULT_PROMPT = "black and white manga panel, dynamic composition, screentone shading, expressive character with action lines, speech bubble placeholders, dramatic angle, crisp ink linework, Japanese manga art style";

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

function parseArgs(argv) {
  const args = { prompt: null, size: "portrait", token: null, ref: null };
  const rest = argv.slice(2);
  const positional = [];
  for (let i = 0; i < rest.length; i++) {
    const a = rest[i];
    if (a === "--size") args.size = rest[++i];
    else if (a === "--token") args.token = rest[++i];
    else if (a === "--ref") args.ref = rest[++i];
    else positional.push(a);
  }
  if (positional.length > 0) args.prompt = positional.join(" ");
  return args;
}

async function makeImage({ token, prompt, size, ref }) {
  const dims = SIZES[size] || SIZES.portrait;
  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: {
      "x-token": token,
      "x-platform": "nieta-app/web",
      "content-type": "application/json",
    },
    body: JSON.stringify(body),
  });

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

  const contentType = res.headers.get("content-type") || "";
  let taskUuid;
  if (contentType.includes("application/json")) {
    const json = await res.json();
    if (typeof json === "string") taskUuid = json;
    else if (json && typeof json === "object") taskUuid = json.task_uuid || json.taskUuid;
  } else {
    const text = (await res.text()).trim();
    try {
      const parsed = JSON.parse(text);
      if (typeof parsed === "string") taskUuid = parsed;
      else if (parsed && typeof parsed === "object") taskUuid = parsed.task_uuid || parsed.taskUuid;
    } catch {
      taskUuid = text.replace(/^"|"$/g, "");
    }
  }

  if (!taskUuid) throw new Error("No task_uuid returned from make_image");
  return taskUuid;
}

async function pollTask(token, 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`, {
      method: "GET",
      headers: {
        "x-token": token,
        "x-platform": "nieta-app/web",
        "content-type": "application/json",
      },
    });

    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;

    const url =
      (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;
    if (url) return url;
    throw new Error(`Task finished with status status but no image URL: JSON.stringify(data)`);
  }
  throw new Error("Timed out waiting for image generation");
}

async function main() {
  const args = parseArgs(process.argv);
  const tokenFlag = args.token;
  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);
  }

  const prompt = args.prompt || DEFAULT_PROMPT;
  const size = args.size || "portrait";

  try {
    const taskUuid = await makeImage({ token: TOKEN, prompt, size, ref: args.ref });
    const url = await pollTask(TOKEN, taskUuid);
    console.log(url);
    process.exit(0);
  } catch (err) {
    console.error(`\n✗ err.message`);
    process.exit(1);
  }
}

main();

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

---
name: app-icon-generator
description: Generate professional app icons for iOS, Android, and web apps instantly with AI. Create polished mobile app icons, app store icons, launcher icons, PWA icons, and software icons. Perfect for developers, startups, indie makers, and designers who need modern, clean app icon artwork without hiring a designer via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# App Icon Generator

Generate professional app icons for iOS, Android, and web apps instantly with AI. Create polished mobile app icons, app store icons, launcher icons, PWA icons, and software icons. Perfect for developers, startups, indie makers, and designers who need modern, clean app icon artwork without hiring a designer.

## 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 app icon generator images.

## Quick start
```bash
node appicongenerator.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/app-icon-generator
```

FILE:README.md
# App Icon Generator

Generate professional app icons for iOS, Android, and web apps from text descriptions using AI. Create polished mobile app icons, app store icons, launcher icons, PWA icons, and software icons instantly -- perfect for developers, startups, indie makers, and designers who need modern, clean app icon artwork without hiring a designer.

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

## Install

```bash
npx skills add blammectrappora/app-icon-generator
```

or

```bash
clawhub install app-icon-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

Generate a square app icon (default):

```bash
node appicongenerator.js "professional app icon design, clean modern style, rounded corners, gradient background, centered symbol, iOS and Android app store ready, high detail, flat design with subtle depth and shadows" --token YOUR_TOKEN
```

Generate with a specific size:

```bash
node appicongenerator.js "minimalist calendar app icon, blue gradient, white date number" --size square --token YOUR_TOKEN
```

Generate using a reference image for style inheritance:

```bash
node appicongenerator.js "weather app icon matching brand style" --ref PICTURE_UUID --token YOUR_TOKEN
```

### Output

Returns a direct image URL.

## Options

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

### Size Reference

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

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

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

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

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

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

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n\u2717 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\u2717 Prompt required. Usage:');
  console.error('  node appicongenerator.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 },
};

if (!SIZES[size]) {
  console.error(`\n\u2717 Invalid size "size". Choose: square, portrait, landscape, tall`);
  process.exit(1);
}

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

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

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 (ref) {
  body.inherit_params = {
    collection_uuid: ref,
    picture_uuid: ref,
  };
}

async function main() {
  // Submit the image generation task
  const createRes = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers,
    body: JSON.stringify(body),
  });

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

  const createData = await createRes.json().catch(() => null);
  let taskUuid;

  if (typeof createData === 'string') {
    taskUuid = createData;
  } else if (createData && createData.task_uuid) {
    taskUuid = createData.task_uuid;
  } else {
    // Response might be plain text
    const text = await createRes.clone().text().catch(() => null);
    if (text && typeof text === 'string' && text.length > 0 && !text.startsWith('{')) {
      taskUuid = text.trim();
    } else {
      console.error('\n\u2717 Unexpected response from API:', createData);
      process.exit(1);
    }
  }

  console.error(`\u2713 Task submitted: taskUuid`);
  console.error('  Polling for result...');

  // Poll for completion
  const MAX_ATTEMPTS = 90;
  const POLL_INTERVAL = 2000;

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

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

    if (!pollRes.ok) {
      console.error(`  Poll attempt attempt failed (pollRes.status), retrying...`);
      continue;
    }

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

    if (status === 'PENDING' || status === 'MODERATION') {
      console.error(`  Attempt attempt/MAX_ATTEMPTS: status`);
      continue;
    }

    // Task is done
    const imageUrl =
      (pollData.artifacts && pollData.artifacts[0] && pollData.artifacts[0].url) ||
      pollData.result_image_url;

    if (imageUrl) {
      console.log(imageUrl);
      process.exit(0);
    } else {
      console.error('\n\u2717 Task completed but no image URL found in response.');
      console.error('  Response:', JSON.stringify(pollData, null, 2));
      process.exit(1);
    }
  }

  console.error(`\n\u2717 Timed out after MAX_ATTEMPTS polling attempts.`);
  process.exit(1);
}

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

FILE:package.json
{"name":"app-icon-generator","version":"1.0.0","type":"module","description":"App Icon Generator — AI-powered app icon generator ai","license":"MIT"}

---
name: children-book-illustration-generator
description: AI children's book illustration generator — create whimsical storybook art, picture book pages, fairy tale scenes, and kids' story illustrations. Perfect for self-publishing authors, KDP creators, teachers, and parents making bedtime story books, educational materials, and nursery wall art via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Children's Book Illustration Generator

AI children's book illustration generator — create whimsical storybook art, picture book pages, fairy tale scenes, and kids' story illustrations. Perfect for self-publishing authors, KDP creators, teachers, and parents making bedtime story books, educational materials, and nursery 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 children book illustration ai generator images.

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

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

## Install
```bash
npx skills add blammectrappora/children-book-illustration-generator
```

FILE:README.md
# Children's Book Illustration Generator

Generate beautiful children's book illustrations from text descriptions using AI. Create whimsical storybook art, picture book pages, fairy tale scenes, and kids' story illustrations — perfect for self-publishing authors, KDP creators, teachers, and parents making bedtime story books, educational materials, and nursery wall art.

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

## Install

```bash
npx skills add blammectrappora/children-book-illustration-generator
```

or

```bash
clawhub install children-book-illustration-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 childrenbookillustrationgenerator.js "a friendly dragon helping a child plant flowers" --token "$NETA_TOKEN"
```

```bash
node childrenbookillustrationgenerator.js "two kittens sharing an umbrella in the rain" --token "$NETA_TOKEN" --size portrait
```

```bash
node childrenbookillustrationgenerator.js "a magical forest with talking animals" --token "$NETA_TOKEN" --ref abc123-uuid
```

Returns a direct image URL.

## Options

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

### Size Dimensions

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

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

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

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

// Parse CLI arguments
let prompt = null;
let size = "landscape";
let tokenFlag = null;
let ref = null;

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

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n\u2717 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\u2717 Prompt required. Usage:');
  console.error('  node childrenbookillustrationgenerator.js "your prompt" --token YOUR_TOKEN');
  process.exit(1);
}

const DEFAULT_PROMPT = "whimsical children's book illustration, storybook art style, soft pastel colors, friendly characters, warm lighting, hand-painted watercolor feel, cute and playful, picture book page";
const fullPrompt = `prompt, DEFAULT_PROMPT`;

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

const chosen = sizes[size];
if (!chosen) {
  console.error(`\u2717 Invalid size "size". Choose: square, portrait, landscape, tall`);
  process.exit(1);
}

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

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

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

async function main() {
  console.error(`Generating children's book illustration (size chosen.widthxchosen.height)...`);

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

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

  const createData = await createRes.json();
  const taskUuid = typeof createData === "string" ? createData : createData.task_uuid;

  if (!taskUuid) {
    console.error("\u2717 No task_uuid returned from API");
    console.error(JSON.stringify(createData));
    process.exit(1);
  }

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

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

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

    if (!pollRes.ok) {
      console.error(`Poll error pollRes.status, retrying...`);
      continue;
    }

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

    if (status === "PENDING" || status === "MODERATION") {
      console.error(`  Status: status (attempt attempt + 1/90)`);
      continue;
    }

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

    if (url) {
      console.log(url);
      process.exit(0);
    } else {
      console.error("\u2717 Task completed but no image URL found");
      console.error(JSON.stringify(pollData));
      process.exit(1);
    }
  }

  console.error("\u2717 Timed out after 90 polling attempts (3 minutes)");
  process.exit(1);
}

main().catch((err) => {
  console.error(`\u2717 err.message`);
  process.exit(1);
});

FILE:package.json
{"name":"children-book-illustration-generator","version":"1.0.0","type":"module","description":"Children's Book Illustration Generator — AI-powered children book illustration ai generator","license":"MIT"}

---
name: sticker-pack-skill
description: Generate ai sticker pack generator images from text descriptions via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# AI Sticker Pack Generator

Generate stunning ai sticker pack 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 sticker pack generator images.

## Quick start
```bash
node stickerpack.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/sticker-pack-skill
```

FILE:README.md
# AI Sticker Pack Generator

Generate ai sticker pack generator images from text descriptions. Describe what you want and get back a direct image URL — no uploads, no local files, just a prompt and an image.

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

## Install

```bash
npx skills add blammectrappora/sticker-pack-skill
```

or

```bash
clawhub install sticker-pack-skill
```

## Usage

```bash
node stickerpack.js "cute sticker design, white outline, transparent background ready" --token YOUR_TOKEN
```

```bash
node stickerpack.js "kawaii cat with sparkles, sticker sheet style" --token YOUR_TOKEN --size portrait
```

```bash
node stickerpack.js "retro pixel art sticker pack, bold colors" --token YOUR_TOKEN --ref PICTURE_UUID
```

Returns a direct image URL.

## Options

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

### Size reference

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

## Token Setup

Get a free trial API token at [neta.art/open](https://www.neta.art/open/), then pass it with the `--token` flag:

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

You can also use shell variable expansion for convenience:

```bash
export NETA_TOKEN="your-token-here"
node stickerpack.js "your prompt" --token "$NETA_TOKEN"
```

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

FILE:package.json
{"name":"sticker-pack-skill","version":"1.0.0","type":"module","description":"AI Sticker Pack Generator — AI-powered ai sticker pack generator","license":"MIT"}

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

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

// Parse CLI arguments
let prompt = null;
let size = "square";
let tokenFlag = null;
let ref = null;

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

const TOKEN = tokenFlag;

if (!TOKEN) {
  console.error('\n\u2717 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\u2717 Prompt required. Usage: node stickerpack.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 dimensions = SIZES[size];
if (!dimensions) {
  console.error(`\n\u2717 Invalid size "size". Choose from: square, portrait, landscape, tall`);
  process.exit(1);
}

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

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 (ref) {
  body.inherit_params = {
    collection_uuid: ref,
    picture_uuid: ref,
  };
}

async function main() {
  // Submit the image generation task
  const createRes = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers,
    body: JSON.stringify(body),
  });

  if (!createRes.ok) {
    const errText = await createRes.text();
    console.error(`\n\u2717 Image creation failed (createRes.status): errText`);
    process.exit(1);
  }

  const createData = await createRes.json().catch(() => null);
  let taskUuid;

  if (typeof createData === "string") {
    taskUuid = createData;
  } else if (createData && createData.task_uuid) {
    taskUuid = createData.task_uuid;
  } else {
    // Response might be plain text
    const textData = await createRes.text().catch(() => null);
    if (textData) {
      taskUuid = textData;
    } else {
      console.error("\n\u2717 Unexpected response format from API.");
      process.exit(1);
    }
  }

  console.error(`Task submitted: taskUuid`);
  console.error("Polling for result...");

  // Poll for completion
  for (let attempt = 0; attempt < 90; attempt++) {
    await new Promise((resolve) => setTimeout(resolve, 2000));

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

    if (!pollRes.ok) {
      console.error(`Poll error (pollRes.status), retrying...`);
      continue;
    }

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

    if (status === "PENDING" || status === "MODERATION") {
      console.error(`Status: status (attempt attempt + 1/90)`);
      continue;
    }

    // Task is done
    const imageUrl =
      (pollData.artifacts && pollData.artifacts[0] && pollData.artifacts[0].url) ||
      pollData.result_image_url;

    if (imageUrl) {
      console.log(imageUrl);
      process.exit(0);
    } else {
      console.error("\n\u2717 Task completed but no image URL found in response.");
      console.error(JSON.stringify(pollData, null, 2));
      process.exit(1);
    }
  }

  console.error("\n\u2717 Timed out after 90 polling attempts.");
  process.exit(1);
}

main().catch((err) => {
  console.error(`\n\u2717 err.message`);
  process.exit(1);
});

---
name: floating-product-generator
description: Generate cinematic floating product shots, levitating product photography, and hovering e-commerce images with dramatic studio lighting — perfect for Shopify stores, Amazon listings, dropshipping catalogs, Instagram ads, luxury brand marketing, creator-economy content, and commercial product photography via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Floating Product Generator

Generate cinematic floating product shots, levitating product photography, and hovering e-commerce images with dramatic studio lighting — perfect for Shopify stores, Amazon listings, dropshipping catalogs, Instagram ads, luxury brand marketing, creator-economy content, and commercial product photography.

## 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 floating product photography generator images.

## Quick start
```bash
node floatingproductgenerator.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/floating-product-generator
```

FILE:README.md
# Floating Product Generator

Generate cinematic floating product shots from text descriptions — levitating product photography, hovering e-commerce images, and dramatic studio-lit commercial shots, all produced from a short text prompt. Ideal for Shopify stores, Amazon listings, dropshipping catalogs, Instagram ads, luxury brand marketing, creator-economy content, and premium product advertising.

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

## Install

```bash
npx skills add blammectrappora/floating-product-generator
```

Or via ClawHub:

```bash
clawhub install floating-product-generator
```

## Usage

```bash
node floatingproductgenerator.js "luxury perfume bottle" --token YOUR_TOKEN
```

More examples:

```bash
# Portrait-orientation floating sneaker shot
node floatingproductgenerator.js "white minimalist sneaker" --size portrait --token YOUR_TOKEN

# Landscape hero image for a smartwatch
node floatingproductgenerator.js "sleek black smartwatch with metallic band" --size landscape --token YOUR_TOKEN

# Square Instagram-ready skincare bottle
node floatingproductgenerator.js "amber glass serum bottle with gold dropper" --size square --token YOUR_TOKEN

# Inherit style from a reference image
node floatingproductgenerator.js "matte black headphones" --ref 00000000-0000-0000-0000-000000000000 --token YOUR_TOKEN
```

## Options

| Flag      | Description                                                            | Default   |
| --------- | ---------------------------------------------------------------------- | --------- |
| `--token` | Neta API token (required)                                              | —         |
| `--size`  | Image size: `portrait`, `landscape`, `square`, `tall`                  | `square`  |
| `--ref`   | Reference image UUID for style inheritance                             | —         |
| `-h`      | Show help                                                              | —         |

### Sizes

| Name        | Dimensions   |
| ----------- | ------------ |
| `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
```

## Output

Returns a direct image URL.

## How it works

The skill takes your short text description, appends a curated cinematic-product-photography prompt suffix, and sends it to the Neta AI image generation API. It then polls the task endpoint until the image is ready and prints the resulting URL to stdout.


FILE:floatingproductgenerator.js
#!/usr/bin/env node
// Floating Product Generator — cinematic floating product photography via Neta AI
// Usage: node floatingproductgenerator.js "your prompt" --token YOUR_TOKEN [--size square] [--ref UUID]

const API_BASE = 'https://api.talesofai.com';

const DEFAULT_PROMPT_SUFFIX =
  'professional product photography, product floating and hovering in mid-air, dramatic cinematic lighting, studio backdrop with soft gradient, crisp shadows, commercial advertising shot, ultra detailed, high-end e-commerce photography, sharp focus, premium brand aesthetic';

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

function parseArgs(argv) {
  const args = { _: [] };
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (a === '--size') args.size = argv[++i];
    else if (a === '--token') args.token = argv[++i];
    else if (a === '--ref') args.ref = argv[++i];
    else if (a === '--help' || a === '-h') args.help = true;
    else args._.push(a);
  }
  return args;
}

function printHelp() {
  console.log(`Floating Product Generator

Usage:
  node floatingproductgenerator.js "your prompt" --token YOUR_TOKEN [options]

Options:
  --token <token>   Neta API token (required) — get one at https://www.neta.art/open/
  --size <size>     portrait | landscape | square | tall  (default: square)
  --ref <uuid>      Reference image UUID for style inheritance
  -h, --help        Show this help

Example:
  node floatingproductgenerator.js "luxury perfume bottle" --token "$NETA_TOKEN"
`);
}

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

async function createTask({ token, prompt, width, height, ref }) {
  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 (ref) {
    body.inherit_params = {
      collection_uuid: ref,
      picture_uuid: ref,
    };
  }

  const res = await fetch(`https://api.talesofai.com/v3/make_image`, {
    method: 'POST',
    headers: {
      'x-token': token,
      'x-platform': 'nieta-app/web',
      'content-type': 'application/json',
    },
    body: JSON.stringify(body),
  });

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

  const text = await res.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(text);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = text.trim().replace(/^"|"$/g, '');
  }

  if (!taskUuid) {
    throw new Error(`No task_uuid in response: text`);
  }
  return taskUuid;
}

async function pollTask({ token, taskUuid }) {
  const maxAttempts = 90;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: {
        'x-token': token,
        'x-platform': 'nieta-app/web',
        'content-type': 'application/json',
      },
    });

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

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

    if (status && status !== 'PENDING' && status !== 'MODERATION') {
      const url =
        (Array.isArray(data.artifacts) && data.artifacts[0] && data.artifacts[0].url) ||
        data.result_image_url;
      if (!url) {
        throw new Error(`Task finished with status status but no image URL found`);
      }
      return url;
    }

    await sleep(2000);
  }
  throw new Error('Timed out waiting for image generation');
}

async function main() {
  const args = parseArgs(process.argv.slice(2));

  if (args.help) {
    printHelp();
    process.exit(0);
  }

  const tokenFlag = args.token;
  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);
  }

  const userPrompt = args._[0];
  if (!userPrompt) {
    console.error('\n✗ Prompt required. Usage: node floatingproductgenerator.js "your prompt" --token YOUR_TOKEN');
    process.exit(1);
  }

  const sizeKey = (args.size || 'square').toLowerCase();
  const size = SIZES[sizeKey];
  if (!size) {
    console.error(`\n✗ Invalid size: sizeKey. Must be one of: Object.keys(SIZES).join(', ')`);
    process.exit(1);
  }

  const fullPrompt = `userPrompt, DEFAULT_PROMPT_SUFFIX`;

  try {
    console.error(`→ Generating floating product image (size.width×size.height)...`);
    const taskUuid = await createTask({
      token: TOKEN,
      prompt: fullPrompt,
      width: size.width,
      height: size.height,
      ref: args.ref,
    });
    console.error(`→ Task created: taskUuid`);
    console.error(`→ Polling for result...`);
    const imageUrl = await pollTask({ token: TOKEN, taskUuid });
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error(`\n✗ err.message`);
    process.exit(1);
  }
}

main();

FILE:package.json
{"name":"floating-product-generator","version":"1.0.0","type":"module","description":"Floating Product Generator — AI-powered floating product photography generator ai","license":"MIT"}

---
name: podcast-cover-generator
description: Generate professional podcast cover art and show artwork for Spotify, Apple Podcasts, YouTube Music, Amazon Music, and Overcast. Create eye-catching 1400x1400 square covers for true crime, comedy, business, interview, educational, storytelling, news, tech, and entertainment podcasts. Perfect for indie podcasters, podcast networks, audio creators, and show hosts needing custom cover design, episode art, show branding, podcast thumbnails, and directory-ready artwork that stands out in search results via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Podcast Cover Generator

Generate professional podcast cover art and show artwork for Spotify, Apple Podcasts, YouTube Music, Amazon Music, and Overcast. Create eye-catching 1400x1400 square covers for true crime, comedy, business, interview, educational, storytelling, news, tech, and entertainment podcasts. Perfect for indie podcasters, podcast networks, audio creators, and show hosts needing custom cover design, episode art, show branding, podcast thumbnails, and directory-ready artwork that stands out in search results.

## 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 podcast cover art generator images.

## Quick start
```bash
node podcastcovergenerator.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/podcast-cover-generator
```

FILE:README.md
# Podcast Cover Generator

Generate professional podcast cover art and show artwork from plain text descriptions. Describe your show — the mood, subject, color palette, central visual — and get back a broadcast-quality square cover ready for Spotify, Apple Podcasts, YouTube Music, Amazon Music, and Overcast. Built for indie podcasters, podcast networks, audio creators, and show hosts who need directory-ready artwork that stands out in search results across true crime, comedy, business, interview, educational, storytelling, news, tech, and entertainment categories.

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

## Install

Via the skills CLI:

```bash
npx skills add blammectrappora/podcast-cover-generator
```

Via ClawHub:

```bash
clawhub install podcast-cover-generator
```

## Usage

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

The first positional argument is your prompt. A cinematic podcast-cover style suffix is appended automatically, so you can focus on describing the subject.

### Examples

Generate a true-crime show cover:

```bash
node podcastcovergenerator.js "shadowy detective silhouette against a neon-lit rainy alley, moody noir atmosphere" --token YOUR_TOKEN
```

Generate a business interview podcast cover:

```bash
node podcastcovergenerator.js "confident founder portrait, clean geometric background, gold and navy palette" --token YOUR_TOKEN
```

Generate a comedy show cover in portrait orientation:

```bash
node podcastcovergenerator.js "two cartoon microphones laughing, playful pastel background" --size portrait --token YOUR_TOKEN
```

Reuse the style of an existing reference image:

```bash
node podcastcovergenerator.js "tech startup podcast, minimal circuit motif" --ref <picture_uuid> --token YOUR_TOKEN
```

### Output

Returns a direct image URL printed to stdout on success. Progress messages go to stderr, so you can pipe the URL cleanly:

```bash
URL=$(node podcastcovergenerator.js "astronomy podcast, deep space nebula" --token YOUR_TOKEN)
echo "$URL"
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `<prompt>` | First positional argument — what you want generated | required |
| `--token` | Neta API token | required |
| `--size` | `square`, `portrait`, `landscape`, or `tall` | `square` |
| `--ref` | Reference image `picture_uuid` for style inheritance | none |
| `-h`, `--help` | Show help | — |

Size presets:

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

## Token setup

The script reads your Neta API token **only** from the `--token` command-line flag. There is no config file, no hidden lookup — whatever you pass to `--token` is what the script uses.

Pass it directly:

```bash
node podcastcovergenerator.js "a cozy storytelling podcast cover" --token sk-xxxxxxxxxxxx
```

Or expand a shell variable you set yourself:

```bash
node podcastcovergenerator.js "a cozy storytelling podcast cover" --token "$NETA_TOKEN"
```

If `--token` is missing the script exits with an error.

---

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

FILE:package.json
{"name":"podcast-cover-generator","version":"1.0.0","type":"module","description":"Podcast Cover Generator — AI-powered podcast cover art generator","license":"MIT"}

FILE:podcastcovergenerator.js
#!/usr/bin/env node
// Podcast Cover Generator — AI-powered podcast cover art via Neta API

const API_BASE = 'https://api.talesofai.com';

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

const DEFAULT_STYLE_SUFFIX = 'professional podcast cover art, bold central visual focus, dramatic lighting, vibrant color palette, modern minimalist design, broadcast quality, square 1:1 composition, eye-catching thumbnail-ready artwork, clean negative space for title typography, cinematic style';

function parseArgs(argv) {
  const args = { prompt: null, size: 'square', token: null, ref: null };
  const rest = argv.slice(2);
  for (let i = 0; i < rest.length; i++) {
    const a = rest[i];
    if (a === '--size') {
      args.size = rest[++i];
    } else if (a === '--token') {
      args.token = rest[++i];
    } else if (a === '--ref') {
      args.ref = rest[++i];
    } else if (a === '--help' || a === '-h') {
      args.help = true;
    } else if (!args.prompt) {
      args.prompt = a;
    }
  }
  return args;
}

function printHelp() {
  console.log(`Podcast Cover Generator — generate podcast cover art from a text prompt

Usage:
  node podcastcovergenerator.js "your description" --token YOUR_TOKEN [options]

Options:
  --size <preset>   square | portrait | landscape | tall  (default: square)
  --token <token>   Neta API token (required)
  --ref <uuid>      Reference image picture_uuid for style inheritance
  -h, --help        Show this help

Get a free trial token at: https://www.neta.art/open/
`);
}

async function createTask({ prompt, size, token, ref }) {
  const dims = SIZES[size] || SIZES.square;
  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 (ref) {
    body.inherit_params = { collection_uuid: ref, picture_uuid: ref };
  }

  const res = await fetch(`https://api.talesofai.com/v3/make_image`, {
    method: 'POST',
    headers: {
      'x-token': token,
      'x-platform': 'nieta-app/web',
      'content-type': 'application/json',
    },
    body: JSON.stringify(body),
  });

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

  const raw = await res.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(raw);
    taskUuid = typeof parsed === 'string' ? parsed : parsed.task_uuid;
  } catch {
    taskUuid = raw.replace(/^"|"$/g, '').trim();
  }
  if (!taskUuid) throw new Error(`No task_uuid in response: raw`);
  return taskUuid;
}

async function pollTask(taskUuid, token) {
  const maxAttempts = 90;
  for (let i = 0; i < maxAttempts; i++) {
    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: {
        'x-token': token,
        'x-platform': 'nieta-app/web',
        'content-type': 'application/json',
      },
    });

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

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

    if (status !== 'PENDING' && status !== 'MODERATION') {
      const url =
        (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
        data.result_image_url;
      if (!url) {
        throw new Error(`Task finished but no image URL. status=status data=JSON.stringify(data)`);
      }
      return url;
    }

    await new Promise((r) => setTimeout(r, 2000));
  }
  throw new Error('Timed out waiting for image generation');
}

async function main() {
  const args = parseArgs(process.argv);

  if (args.help) {
    printHelp();
    process.exit(0);
  }

  if (!args.prompt) {
    console.error('\n✗ Prompt required. Usage: node podcastcovergenerator.js "your description" --token YOUR_TOKEN');
    process.exit(1);
  }

  const tokenFlag = args.token;
  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 (!SIZES[args.size]) {
    console.error(`\n✗ Unknown size "args.size". Use: square | portrait | landscape | tall`);
    process.exit(1);
  }

  const fullPrompt = `args.prompt, DEFAULT_STYLE_SUFFIX`;

  console.error(`→ Generating args.size image...`);
  try {
    const taskUuid = await createTask({
      prompt: fullPrompt,
      size: args.size,
      token: TOKEN,
      ref: args.ref,
    });
    console.error(`  task_uuid: taskUuid`);
    console.error('  polling...');
    const url = await pollTask(taskUuid, TOKEN);
    console.log(url);
    process.exit(0);
  } catch (err) {
    console.error(`\n✗ err.message`);
    process.exit(1);
  }
}

main();

---
name: logo-design-generator
description: AI logo generator and logo design maker — create professional brand logos, company emblems, startup icons, app logos, and business identity marks. Design custom logo concepts with clean modern aesthetics for any brand, business, or project via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Logo Design Generator

AI logo generator and logo design maker — create professional brand logos, company emblems, startup icons, app logos, and business identity marks. Design custom logo concepts with clean modern aesthetics for any brand, business, or project.

## 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 logo generator images.

## Quick start
```bash
node logodesigngenerator.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/logo-design-generator
```

FILE:README.md
# Logo Design Generator

AI logo generator and logo design maker — generate professional brand logos, company emblems, startup icons, app logos, and business identity marks from text descriptions. Design custom logo concepts with clean modern aesthetics for any brand, business, or project.

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

## Install

```bash
npx skills add blammectrappora/logo-design-generator
```

Or via ClawHub:

```bash
clawhub install logo-design-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

Generate a logo with the default square size:

```bash
node logodesigngenerator.js "Professional logo design, clean minimal vector style, centered composition, simple iconic symbol, white background, brand identity mark" --token YOUR_TOKEN
```

Generate a landscape logo:

```bash
node logodesigngenerator.js "Modern tech startup logo, geometric shapes, blue gradient" --size landscape --token YOUR_TOKEN
```

Use a reference image for style inheritance:

```bash
node logodesigngenerator.js "Minimalist coffee shop logo" --ref PICTURE_UUID --token YOUR_TOKEN
```

Returns a direct image URL.

## Options

| Option | Description | Default |
|--------|-------------|---------|
| `--token` | Neta API token (required) | — |
| `--size` | Image dimensions: `square`, `portrait`, `landscape`, `tall` | `square` |
| `--ref` | Reference image UUID for style inheritance | — |

### Size Reference

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

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

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

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

// Parse CLI arguments
let prompt = null;
let size = "square";
let ref = null;
let tokenFlag = 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]) {
    ref = args[++i];
  } else if (!args[i].startsWith("--") && !prompt) {
    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. Usage: node logodesigngenerator.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 dimensions = SIZES[size];
if (!dimensions) {
  console.error(`\n✗ Invalid size "size". Choose from: square, portrait, landscape, tall`);
  process.exit(1);
}

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

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 (ref) {
  body.inherit_params = {
    collection_uuid: ref,
    picture_uuid: ref,
  };
}

async function main() {
  console.error(`\n● Generating logo (size dimensions.width×dimensions.height)…`);

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

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

  const createData = await createRes.json();
  const taskUuid = typeof createData === "string" ? createData : createData.task_uuid;

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

  console.error(`● Task submitted: taskUuid`);
  console.error("● Polling for result…");

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

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

    if (!pollRes.ok) {
      console.error(`  ⚠ Poll error pollRes.status, retrying…`);
      continue;
    }

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

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

    // Task is done
    const url =
      (pollData.artifacts && pollData.artifacts[0] && pollData.artifacts[0].url) ||
      pollData.result_image_url;

    if (url) {
      console.error("● Done!");
      console.log(url);
      process.exit(0);
    } else {
      console.error("\n✗ Task completed but no image URL found");
      console.error(JSON.stringify(pollData, null, 2));
      process.exit(1);
    }
  }

  console.error("\n✗ Timed out after 90 polling attempts (3 minutes)");
  process.exit(1);
}

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

FILE:package.json
{"name":"logo-design-generator","version":"1.0.0","type":"module","description":"Logo Design Generator — AI-powered ai logo generator","license":"MIT"}

---
name: stained-glass-art-generator
description: Generate stunning stained glass style art and illustrations. Create luminous jewel-toned stained glass portraits, animals, landscapes, and decorative panels — perfect for wall art, print-on-demand, posters, church window designs, and mosaic-inspired artwork via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Stained Glass Art Generator

Generate stunning stained glass style art and illustrations. Create luminous jewel-toned stained glass portraits, animals, landscapes, and decorative panels — perfect for wall art, print-on-demand, posters, church window designs, and mosaic-inspired artwork.

## 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 stained glass art generator images.

## Quick start
```bash
node stainedglassartgenerator.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/stained-glass-art-generator
```

FILE:README.md
# Stained Glass Art Generator

Generate stunning stained glass style art and illustrations from text descriptions. Create luminous jewel-toned stained glass portraits, animals, landscapes, and decorative panels — perfect for wall art, print-on-demand, posters, church window designs, and mosaic-inspired artwork.

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

## Install

```bash
npx skills add blammectrappora/stained-glass-art-generator
```

or

```bash
clawhub install stained-glass-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

Generate a stained glass art panel with default settings (portrait size):

```bash
node stainedglassartgenerator.js "a majestic lion in stained glass style with rich amber and gold tones" --token "$NETA_TOKEN"
```

Generate a landscape stained glass scene:

```bash
node stainedglassartgenerator.js "a serene mountain lake scene in stained glass, deep blues and greens" --token "$NETA_TOKEN" --size landscape
```

Generate a square stained glass design:

```bash
node stainedglassartgenerator.js "an intricate rose window cathedral design with ruby red and sapphire blue glass" --token "$NETA_TOKEN" --size square
```

Use a reference image UUID for style inheritance:

```bash
node stainedglassartgenerator.js "a peacock with jewel-toned feathers in stained glass" --token "$NETA_TOKEN" --ref YOUR_REFERENCE_UUID
```

Returns a direct image URL.

## Options

| Option | Description | Default |
|--------|-------------|---------|
| `--token` | Neta API token (required) | — |
| `--size` | Image dimensions: `portrait`, `landscape`, `square`, `tall` | `portrait` |
| `--ref` | Reference image UUID for style inheritance | — |

### Size Reference

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

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

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

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

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

// Parse CLI arguments
let prompt = null;
let size = "portrait";
let tokenFlag = null;
let ref = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--token" && i + 1 < args.length) {
    tokenFlag = args[++i];
  } else if (args[i] === "--size" && i + 1 < args.length) {
    size = args[++i];
  } else if (args[i] === "--ref" && i + 1 < args.length) {
    ref = args[++i];
  } else if (!prompt && !args[i].startsWith("--")) {
    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 stained glass art panel, luminous jewel-toned colors, bold dark lead lines separating glass segments, radiant light shining through translucent colored glass, intricate detailed glasswork pattern, cathedral window aesthetic";
}

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

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

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

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

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

console.error(`\n◈ Stained Glass Art Generator`);
console.error(`  Prompt: "prompt"`);
console.error(`  Size:   size (chosen.width×chosen.height)`);
if (ref) console.error(`  Ref:    ref`);
console.error("");

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

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

  const data = await res.json();

  if (typeof data === "string") return data;
  if (data.task_uuid) return data.task_uuid;

  console.error("✗ Unexpected response:", JSON.stringify(data));
  process.exit(1);
}

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

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

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

    if (!res.ok) {
      console.error(`✗ Poll error res.status`);
      continue;
    }

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

    if (status === "PENDING" || status === "MODERATION") {
      console.error(`  ⏳ status… (i + 1/maxAttempts)`);
      continue;
    }

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

    if (url) {
      console.log(url);
      return;
    }

    console.error("✗ No image URL in response:", JSON.stringify(data));
    process.exit(1);
  }

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

try {
  const taskUuid = await createTask();
  console.error(`  Task: taskUuid`);
  await pollTask(taskUuid);
} catch (err) {
  console.error(`✗ err.message`);
  process.exit(1);
}

---
name: texture-art-generator
description: Generate stunning satisfying texture art and hyperrealistic material images — glass, crystal, liquid, jelly, wax, soap, and iridescent surfaces captured in breathtaking macro detail. Perfect for ASMR content creators, product design backgrounds, Instagram aesthetics, TikTok visual content, and short-form video thumbnails. Also known as material art generator, surface texture art, and macro texture photography via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Texture Art Generator

Generate stunning satisfying texture art and hyperrealistic material images — glass, crystal, liquid, jelly, wax, soap, and iridescent surfaces captured in breathtaking macro detail. Perfect for ASMR content creators, product design backgrounds, Instagram aesthetics, TikTok visual content, and short-form video thumbnails. Also known as material art generator, surface texture art, and macro texture photography.

## 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 satisfying texture art generator images.

## Quick start
```bash
node textureartgenerator.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/texture-art-generator
```

FILE:README.md
# Texture Art Generator

Generate stunning satisfying texture art and hyperrealistic material images from text descriptions — glass, crystal, liquid jelly, melted wax, soap bubbles, and iridescent surfaces captured in breathtaking macro detail. Perfect for ASMR content creators, product design backgrounds, Instagram aesthetics, TikTok visual content, and short-form video thumbnails.

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

## Install

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

```bash
clawhub install texture-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 textureartgenerator.js "prompt describing the texture" --token YOUR_TOKEN [--size SIZE] [--ref UUID]
```

If no prompt is supplied, a built-in default prompt is used:

> hyperrealistic macro photograph of a satisfying texture surface — glass crystal, iridescent liquid jelly, melted wax, soap bubble, or shimmering material — studio lighting, ultra-detailed microscopic surface detail, ASMR aesthetic, clean minimalist background, sharp focus

## Options

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

### Size dimensions

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

## Examples

**Default satisfying texture (square):**
```bash
node textureartgenerator.js --token "$NETA_TOKEN"
```

**Iridescent soap bubble macro:**
```bash
node textureartgenerator.js "extreme closeup of a soap bubble surface, rainbow iridescent film, bokeh background, ultra-sharp" --token "$NETA_TOKEN"
```

**Melted wax texture, portrait:**
```bash
node textureartgenerator.js "melted candle wax pooling, warm amber tones, macro photography, glossy surface reflections" --token "$NETA_TOKEN" --size portrait
```

**Crystal glass refraction:**
```bash
node textureartgenerator.js "cracked crystal glass surface, light refractions, prismatic spectrum, studio light" --token "$NETA_TOKEN" --size landscape
```

**With style reference:**
```bash
node textureartgenerator.js "liquid mercury ripple surface" --token "$NETA_TOKEN" --ref xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

## Output

Returns a direct image URL printed to stdout. Progress messages are written to stderr so you can pipe the URL directly:

```bash
URL=$(node textureartgenerator.js "jelly cube macro" --token "$NETA_TOKEN")
echo "Image ready: $URL"
```

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

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

FILE:textureartgenerator.js
#!/usr/bin/env node
// Texture Art Generator — generates satisfying texture art via Neta AI API

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 = 'hyperrealistic macro photograph of a satisfying texture surface — glass crystal, iridescent liquid jelly, melted wax, soap bubble, or shimmering material — studio lighting, ultra-detailed microscopic surface detail, ASMR aesthetic, clean minimalist background, sharp focus';
}

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;

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

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 };
}

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

async function main() {
  // Submit job
  const submitRes = await fetch('https://api.talesofai.com/v3/make_image', {
    method: 'POST',
    headers: HEADERS,
    body: JSON.stringify(body),
  });

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

  const submitData = await submitRes.json();
  const taskUuid = typeof submitData === 'string' ? submitData : submitData.task_uuid;

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

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

  // Poll for result
  const MAX_ATTEMPTS = 90;
  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
    await sleep(2000);

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

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

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

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

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

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

    if (!url) {
      console.error('✗ No image URL in response:', 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('✗ Unexpected error:', err.message);
  process.exit(1);
});

---
name: coloring-page-generator
description: AI coloring page generator — create printable black and white coloring pages, adult coloring book pages, kids coloring sheets, and coloring book illustrations from any description. Generate mandala coloring pages, animal coloring pages, fantasy coloring pages, and custom line art instantly via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Coloring Page Generator

AI coloring page generator — create printable black and white coloring pages, adult coloring book pages, kids coloring sheets, and coloring book illustrations from any description. Generate mandala coloring pages, animal coloring pages, fantasy coloring pages, and custom line art 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 coloring page generator images.

## Quick start
```bash
node coloringpagegenerator.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/coloring-page-generator
```

FILE:README.md
# Coloring Page Generator

Generate printable black and white coloring pages from text descriptions using AI. Describe any scene, character, pattern, or subject and receive clean line art ready for printing — kids coloring sheets, adult coloring book pages, mandala coloring pages, animal coloring pages, fantasy coloring pages, and more.

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/coloring-page-generator
```

**Via ClawHub:**
```bash
clawhub install coloring-page-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 coloringpagegenerator.js "<description>" --token YOUR_TOKEN [--size <size>] [--ref <uuid>]
```

### Examples

```bash
# Simple kids coloring page
node coloringpagegenerator.js "a friendly elephant holding a bunch of balloons" --token "$NETA_TOKEN"

# Adult mandala coloring page
node coloringpagegenerator.js "intricate geometric mandala with floral patterns" --token "$NETA_TOKEN" --size square

# Fantasy scene in landscape orientation
node coloringpagegenerator.js "a dragon perched on a castle tower at sunset" --token "$NETA_TOKEN" --size landscape

# Tall portrait coloring page
node coloringpagegenerator.js "a fairy standing in an enchanted forest" --token "$NETA_TOKEN" --size tall

# With a style reference image
node coloringpagegenerator.js "underwater ocean scene with fish and coral" --token "$NETA_TOKEN" --ref abc123-uuid
```

### Output

Returns a direct image URL. Download or open it in your browser to view and print.

---

## Options

| Flag | Values | Default | Description |
|------|--------|---------|-------------|
| `--size` | `portrait`, `landscape`, `square`, `tall` | `portrait` | Output image dimensions |
| `--token` | string | *(required)* | Your Neta API token |
| `--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 Style

When no custom prompt suffix is added, images are generated with the default coloring page style:

> black and white line art coloring page, clean outlines, no shading, no color fills, white background, detailed illustration suitable for coloring, bold clear lines, printable coloring book style

You can override this by crafting your own descriptive prompt.


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

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) {
  // Use default prompt if none provided
  prompt = 'black and white line art coloring page, clean outlines, no shading, no color fills, white background, detailed illustration suitable for coloring, bold clear lines, printable coloring book 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,
        ...(body ? { 'content-length': Buffer.byteLength(JSON.stringify(body)) } : {}),
      },
    };

    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);
        }
      });
    });

    req.on('error', reject);

    if (body) {
      req.write(JSON.stringify(body));
    }
    req.end();
  });
}

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

async function main() {
  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 makeRes = await request('POST', 'https://api.talesofai.com/v3/make_image', body);

  let taskUuid;
  if (typeof makeRes === 'string') {
    taskUuid = makeRes;
  } else {
    taskUuid = 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 MAX_ATTEMPTS = 90;

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

    const pollRes = await request('GET', pollUrl, null);

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

    // Done
    const url =
      (pollRes.artifacts && pollRes.artifacts[0] && 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().catch((err) => {
  console.error('✗ Error:', err.message);
  process.exit(1);
});

FILE:package.json
{"name":"coloring-page-generator","version":"1.0.0","type":"module","description":"Coloring Page Generator — AI-powered coloring page generator ai","license":"MIT"}

---
name: fantasy-map-generator
description: AI fantasy map generator for worldbuilders, tabletop RPG campaigns, and game designers. Create custom fantasy world maps, dungeon maps, kingdom maps, and lore art — perfect for D&D, Pathfinder, and indie game development via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Fantasy Map Generator

AI fantasy map generator for worldbuilders, tabletop RPG campaigns, and game designers. Create custom fantasy world maps, dungeon maps, kingdom maps, and lore art — perfect for D&D, Pathfinder, and indie game development.

## 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 fantasy map generator images.

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

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

## Install
```bash
npx skills add blammectrappora/fantasy-map-generator
```

FILE:README.md
# Fantasy Map Generator

Generate stunning fantasy maps from text descriptions using AI. Describe your world — its mountains, kingdoms, rivers, dungeons, and lore — and receive a richly illustrated cartographic image ready for your campaign, game, or creative project. Ideal for D&D, Pathfinder, tabletop RPGs, worldbuilding, and indie game development.

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/fantasy-map-generator
```

**Via clawhub:**
```bash
clawhub install fantasy-map-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 fantasymapgenerator.js "PROMPT" --token YOUR_TOKEN [--size SIZE] [--ref UUID]
```

If no prompt is provided, a default fantasy world map prompt is used.

### Examples

```bash
# Classic parchment world map
node fantasymapgenerator.js "hand-drawn parchment world map with mountains, forests, and ancient kingdoms" --token "$NETA_TOKEN"

# Dark dungeon map
node fantasymapgenerator.js "top-down dungeon map, stone corridors, torch-lit chambers, treasure room, ink on aged paper" --token "$NETA_TOKEN"

# Landscape orientation (default)
node fantasymapgenerator.js "vast continent map with coastal cities and inland empires" --token "$NETA_TOKEN" --size landscape

# Portrait orientation
node fantasymapgenerator.js "tall kingdom map showing northern tundra to southern desert" --token "$NETA_TOKEN" --size portrait

# With style reference
node fantasymapgenerator.js "island archipelago with pirate coves" --token "$NETA_TOKEN" --ref xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

### Output

Returns a direct image URL printed to stdout.

---

## Options

| Flag | Description | Default |
|------|-------------|---------|
| `--token` | Neta API token (required) | — |
| `--size` | Output size: `landscape`, `portrait`, `square`, `tall` | `landscape` |
| `--ref` | Picture UUID to inherit style from | — |

### Size Dimensions

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

---

## Default Prompt

When called without a prompt, the skill uses:

> fantasy world map, hand-drawn cartographic illustration, parchment texture, detailed terrain with mountains forests rivers and oceans, labeled cities and kingdoms, decorative compass rose, ornate borders, medieval fantasy aesthetic, bird's eye view, rich warm tones


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

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

let prompt = null;
let size = "landscape";
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 =
    "fantasy world map, hand-drawn cartographic illustration, parchment texture, detailed terrain with mountains forests rivers and oceans, labeled cities and kingdoms, decorative compass rose, ornate borders, medieval fantasy aesthetic, bird's eye view, rich warm tones";
}

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);
}

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.landscape;

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

function request(method, hostname, path, body) {
  return new Promise((resolve, reject) => {
    const data = body ? JSON.stringify(body) : null;
    const options = {
      hostname,
      path,
      method,
      headers: {
        ...HEADERS,
        ...(data ? { "content-length": Buffer.byteLength(data) } : {}),
      },
    };
    const req = https.request(options, (res) => {
      let raw = "";
      res.on("data", (chunk) => (raw += chunk));
      res.on("end", () => {
        try {
          resolve(JSON.parse(raw));
        } catch {
          resolve(raw.trim());
        }
      });
    });
    req.on("error", reject);
    if (data) req.write(data);
    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",
    "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("✗ Failed to get task UUID:", JSON.stringify(makeRes));
    process.exit(1);
  }

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

  for (let attempt = 0; attempt < 90; attempt++) {
    await sleep(2000);

    const poll = await request(
      "GET",
      "api.talesofai.com",
      `/v1/artifact/task/taskUuid`,
      null
    );

    const status = poll.task_status;

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

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

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

    if (!url) {
      console.error("✗ No image URL in response:", JSON.stringify(poll));
      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("✗ Error:", err.message || err);
  process.exit(1);
});

FILE:package.json
{"name":"fantasy-map-generator","version":"1.0.0","type":"module","description":"Fantasy Map Generator — AI-powered fantasy map generator ai","license":"MIT"}