omactiengartelle

---
name: concert-poster-generator
description: Generate bold concert posters, gig flyers, music event banners, band promo art, festival posters, club night flyers, and live show announcement designs. Perfect for indie musicians, DJs, venue promoters, Bandcamp artists, and tour managers who need eye-catching cinematic poster artwork in seconds via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Concert Poster Generator

Generate bold concert posters, gig flyers, music event banners, band promo art, festival posters, club night flyers, and live show announcement designs. Perfect for indie musicians, DJs, venue promoters, Bandcamp artists, and tour managers who need eye-catching cinematic poster artwork in seconds.

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

## Quick start
```bash
node concertpostergenerator.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 omactiengartelle/concert-poster-generator
```

FILE:README.md
# Concert Poster Generator

Generate bold, cinematic concert poster artwork from a text description in seconds. Designed for indie musicians, DJs, venue promoters, Bandcamp artists, and tour managers who need eye-catching gig flyers, festival posters, club night banners, and live show announcement 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

Via the ClawHub CLI:

```bash
npx skills add omactiengartelle/concert-poster-generator
```

Or with the ClawHub installer:

```bash
clawhub install concert-poster-generator
```

## Usage

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

### Examples

Generate a portrait gig poster:

```bash
node concertpostergenerator.js "midnight synthwave concert poster, neon skyline, cinematic" --token YOUR_TOKEN
```

Generate a landscape festival banner:

```bash
node concertpostergenerator.js "summer indie rock festival poster, sunset crowd, bold typography" \
  --size landscape --token YOUR_TOKEN
```

Inherit style from a reference image:

```bash
node concertpostergenerator.js "underground techno club night flyer" \
  --ref 1234abcd-5678-90ef-uuid --token YOUR_TOKEN
```

Returns a direct image URL.

## Options

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

Size dimensions:

- `portrait` — 832 × 1216
- `landscape` — 1216 × 832
- `square` — 1024 × 1024
- `tall` — 704 × 1408

## Token setup

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

Pass the token to the script using the `--token` flag:

```bash
node concertpostergenerator.js "neon punk show poster" --token YOUR_TOKEN
```

You can also expand it from your shell:

```bash
node concertpostergenerator.js "neon punk show poster" --token "$NETA_TOKEN"
```

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

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

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

const DEFAULT_PROMPT = 'bold concert poster design, dramatic stage lighting, vibrant typography composition, high contrast cinematic mood, music event flyer aesthetic, eye-catching gig poster art';

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('--') && prompt === null) {
      prompt = a;
    }
  }

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

async function main() {
  const { prompt, 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 = prompt || DEFAULT_PROMPT;

  const dims = SIZES[size];
  if (!dims) {
    console.error(`\n✗ Invalid size: size. Use one of: 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: 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: "PROMPT"`);
  console.error(`  Size: size (dims.width×dims.height)`);

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

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

  const rawText = await createRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(rawText);
    if (typeof parsed === 'string') {
      taskUuid = parsed;
    } else if (parsed && parsed.task_uuid) {
      taskUuid = parsed.task_uuid;
    } else {
      taskUuid = rawText.replace(/^"|"$/g, '');
    }
  } 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 result...');

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

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

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

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

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

    let url = null;
    if (Array.isArray(data.artifacts) && data.artifacts.length > 0) {
      url = data.artifacts[0].url;
    }
    if (!url && data.result_image_url) {
      url = data.result_image_url;
    }

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

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

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

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

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

---
name: 90s-anime-art-generator
description: Generate 90s anime art and retro OVA-style illustrations with that nostalgic 1990s Japanese animation aesthetic — flat cel-shaded colors, hand-drawn line art, analog film grain, and vintage shoujo/seinen vibes. Perfect for retro anime portraits, nostalgic profile pictures, vaporwave anime aesthetics, classic OVA fan art, 90s manga-inspired illustrations, and retro Japanese animation style art via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# 90s Anime Art Generator

Generate 90s anime art and retro OVA-style illustrations with that nostalgic 1990s Japanese animation aesthetic — flat cel-shaded colors, hand-drawn line art, analog film grain, and vintage shoujo/seinen vibes. Perfect for retro anime portraits, nostalgic profile pictures, vaporwave anime aesthetics, classic OVA fan art, 90s manga-inspired illustrations, and retro Japanese animation style 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 90s anime art generator images.

## Quick start
```bash
node 90sanimeartgenerator.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 omactiengartelle/90s-anime-art-generator
```

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

const DEFAULT_PROMPT = '1990s anime art style, retro OVA aesthetic, flat cel-shaded colors, vintage analog film grain, hand-drawn line art, soft pastel palette, nostalgic shoujo/seinen composition, expressive eyes, dramatic lighting, classic Japanese animation';

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 args._.push(a);
  }
  return args;
}

const argv = parseArgs(process.argv.slice(2));
const userPrompt = argv._[0];
const sizeKey = argv.size || 'portrait';
const tokenFlag = argv.token;
const refUuid = argv.ref;

const TOKEN = tokenFlag;

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

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

const PROMPT = userPrompt
  ? `DEFAULT_PROMPT, userPrompt`
  : DEFAULT_PROMPT;

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

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

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

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

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

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

  return taskUuid;
}

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

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

    throw new Error(`Task finished without image URL: JSON.stringify(data)`);
  }
  throw new Error('Timed out waiting for image generation.');
}

(async () => {
  try {
    const taskUuid = await createTask();
    const imageUrl = await pollTask(taskUuid);
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error(`\n✗ err.message`);
    process.exit(1);
  }
})();

FILE:README.md
# 90s Anime Art Generator

Generate retro 1990s anime art and OVA-style illustrations from text descriptions. This skill turns a text prompt into a nostalgic Japanese animation–style image — flat cel-shaded colors, hand-drawn line art, analog film grain, soft pastel palettes, expressive eyes, and that unmistakable shoujo/seinen mood from the golden era of anime.

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

Use it for retro anime portraits, nostalgic profile pictures, vaporwave anime aesthetics, classic OVA fan art, 90s manga-inspired illustrations, and any retro Japanese animation style art you can describe in words.

## Install

Via the ClawHub CLI:

```bash
npx skills add omactiengartelle/90s-anime-art-generator
```

Or via clawhub:

```bash
clawhub install 90s-anime-art-generator
```

## Usage

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

### Examples

A retro anime portrait:

```bash
node 90sanimeartgenerator.js "a young swordsman standing on a cliff at sunset, cape flowing in the wind" --token YOUR_TOKEN
```

A nostalgic city scene:

```bash
node 90sanimeartgenerator.js "neon-lit Tokyo street in the rain, lone schoolgirl with an umbrella" --size landscape --token YOUR_TOKEN
```

Reuse the style of an existing image:

```bash
node 90sanimeartgenerator.js "a mecha pilot in the cockpit" --ref PICTURE_UUID --token YOUR_TOKEN
```

## Options

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

### Sizes

| Name | 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":"90s-anime-art-generator","version":"1.0.0","type":"module","description":"90s Anime Art Generator — AI-powered 90s anime art generator","license":"MIT"}

---
name: dark-academia-art-generator
description: Dark academia art generator for moody scholarly aesthetic images: candlelit libraries, vintage tweed portraits, old leather books, classical statues, autumn campus scenes. Perfect for Pinterest boards, Tumblr posts, BookTok content, study aesthetic moodboards, journal covers, study playlist art, cottagecore and gothic academia communities, vintage academic poster designs, and atmospheric backgrounds for writers, students, and aesthetic lovers via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Dark Academia Art Generator

Dark academia art generator for moody scholarly aesthetic images: candlelit libraries, vintage tweed portraits, old leather books, classical statues, autumn campus scenes. Perfect for Pinterest boards, Tumblr posts, BookTok content, study aesthetic moodboards, journal covers, study playlist art, cottagecore and gothic academia communities, vintage academic poster designs, and atmospheric backgrounds for writers, students, and 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 dark academia art generator images.

## Quick start
```bash
node darkacademiaartgenerator.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 omactiengartelle/dark-academia-art-generator
```

FILE:README.md
# Dark Academia Art Generator

Generate moody, scholarly dark academia aesthetic images from text descriptions — candlelit libraries, vintage tweed portraits, old leather books, classical statues, and autumn campus scenes. Perfect for Pinterest boards, Tumblr posts, BookTok content, study aesthetic moodboards, journal covers, study playlist art, cottagecore and gothic academia communities, vintage academic poster designs, and atmospheric backgrounds for writers, students, and aesthetic lovers.

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

## Install

```bash
npx skills add omactiengartelle/dark-academia-art-generator
```

Or via ClawHub:

```bash
clawhub install dark-academia-art-generator
```

## Usage

```bash
node darkacademiaartgenerator.js "your text description" --token YOUR_TOKEN
```

### Examples

```bash
# Default portrait of a candlelit library scene
node darkacademiaartgenerator.js "candlelit antique library with leather-bound books and ink quill on oak desk" --token YOUR_TOKEN

# Landscape autumn campus scene
node darkacademiaartgenerator.js "gothic university courtyard in autumn, golden hour, fog, ivy-covered stone arches" --size landscape --token YOUR_TOKEN

# Square portrait of a tweed-clad scholar
node darkacademiaartgenerator.js "portrait of young scholar in vintage tweed jacket reading by candlelight, chiaroscuro lighting" --size square --token YOUR_TOKEN

# Use a reference image for style inheritance
node darkacademiaartgenerator.js "marble bust on stack of leather books, parchment papers, moody lighting" --ref PICTURE_UUID --token YOUR_TOKEN
```

## Options

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

### 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:darkacademiaartgenerator.js
#!/usr/bin/env node
import { argv, exit, stdout } from 'node:process';

const DEFAULT_PROMPT = 'dark academia aesthetic, candlelit antique library, leather-bound books stacked on oak desk, vintage tweed and wool coat, autumn golden hour light through tall arched windows, classical marble bust, parchment papers, ink quill, moody chiaroscuro lighting, film grain, muted earth tones of brown burgundy and forest green, scholarly atmosphere, painterly cinematic composition';

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 makeImage({ 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 text`);
  }

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

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

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

    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/task_uuid`, {
      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?.[0]?.url || data.result_image_url;
    if (!url) throw new Error(`Task finished but no image URL: JSON.stringify(data)`);
    return url;
  }
  throw new Error('Polling timed out after 90 attempts');
}

async function main() {
  const args = parseArgs(argv.slice(2));
  const PROMPT = args.prompt || DEFAULT_PROMPT;
  const TOKEN = args.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 dims = SIZES[args.size] || SIZES.portrait;

  const task_uuid = await makeImage({
    token: TOKEN,
    prompt: PROMPT,
    width: dims.width,
    height: dims.height,
    ref: args.ref,
  });

  const url = await pollTask({ token: TOKEN, task_uuid });
  stdout.write(url + '\n');
  exit(0);
}

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

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

---
name: liminal-space-generator
description: Generate eerie liminal space images, dreamcore backgrounds, and backrooms-style scenes — empty hallways, abandoned pools, fluorescent-lit rooms, uncanny dreamscapes, analog horror aesthetics, nostalgic unsettling environments, weirdcore and oneiric art for creators, horror writers, aesthetic Tumblr/TikTok accounts, and atmospheric game or video backdrops via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Liminal Space Generator

Generate eerie liminal space images, dreamcore backgrounds, and backrooms-style scenes — empty hallways, abandoned pools, fluorescent-lit rooms, uncanny dreamscapes, analog horror aesthetics, nostalgic unsettling environments, weirdcore and oneiric art for creators, horror writers, aesthetic Tumblr/TikTok accounts, and atmospheric game or video backdrops.

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

## Quick start
```bash
node liminalspacegenerator.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 omactiengartelle/liminal-space-generator
```

FILE:README.md
# Liminal Space Generator

Generate eerie liminal space images, dreamcore backgrounds, and backrooms-style scenes from text descriptions — empty hallways, abandoned pools, fluorescent-lit rooms, uncanny dreamscapes, analog horror aesthetics, and nostalgic unsettling environments. Perfect for horror writers, aesthetic Tumblr/TikTok accounts, weirdcore creators, and atmospheric game or video backdrops.

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 omactiengartelle/liminal-space-generator
```

Via ClawHub:

```bash
clawhub install liminal-space-generator
```

## Usage

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

### Examples

Generate a default liminal hallway:

```bash
node liminalspacegenerator.js "liminal space, eerie empty hallway with fluorescent lighting, worn carpet, dreamcore aesthetic" --token YOUR_TOKEN
```

Generate a portrait-oriented abandoned pool scene:

```bash
node liminalspacegenerator.js "abandoned indoor pool, flickering fluorescent lights, tiled walls, uncanny backrooms atmosphere" --size portrait --token YOUR_TOKEN
```

Generate with a reference image for style inheritance:

```bash
node liminalspacegenerator.js "empty arcade at night, dreamcore, VHS grain" --ref <picture_uuid> --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `--size` | Output size: `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 | none |

## 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 via the `--token` flag on every invocation:

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

You can also use shell expansion to inject a token from your shell environment:

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


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

const DEFAULT_PROMPT = 'liminal space, eerie empty hallway with fluorescent lighting, worn carpet, dreamcore aesthetic, uncanny atmosphere, analog horror feel, nostalgic unsettling mood, backrooms style, muted yellow and beige tones, deep perspective, photographic realism with slight VHS grain';

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: '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 args.positional.push(a);
  }
  return args;
}

async function main() {
  const argv = process.argv.slice(2);
  const { positional, size, token: tokenFlag, ref } = parseArgs(argv);
  const prompt = positional[0] || 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);
  }

  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: "prompt"`);
  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 in response');
    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`, {
      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 finished with status status but no image URL found`);
    process.exit(1);
  }

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

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

FILE:package.json
{"name":"liminal-space-generator","version":"1.0.0","type":"module","description":"Liminal Space Generator — AI-powered liminal space generator","license":"MIT"}

---
name: dark-fantasy-art-generator
description: Generate dark fantasy artwork, grimdark illustrations, and gothic horror scenes. Perfect for D&D campaigns, metal album covers, Soulslike game concepts, dark fantasy novel covers, horror art, eldritch creatures, haunted castles, cursed knights, and atmospheric moody worldbuilding imagery via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Dark Fantasy Art Generator

Generate dark fantasy artwork, grimdark illustrations, and gothic horror scenes. Perfect for D&D campaigns, metal album covers, Soulslike game concepts, dark fantasy novel covers, horror art, eldritch creatures, haunted castles, cursed knights, and atmospheric moody worldbuilding imagery.

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

## Quick start
```bash
node darkfantasyartgenerator.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 omactiengartelle/dark-fantasy-art-generator
```

FILE:README.md
# Dark Fantasy Art Generator

Generate dark fantasy artwork, grimdark illustrations, and gothic horror scenes from text descriptions. Perfect for D&D campaigns, metal album covers, Soulslike game concepts, dark fantasy novel covers, horror art, eldritch creatures, haunted castles, cursed knights, and atmospheric moody worldbuilding imagery — all from a short text prompt.

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

## Install

```bash
npx skills add omactiengartelle/dark-fantasy-art-generator
```

Or via ClawHub:

```bash
clawhub install dark-fantasy-art-generator
```

## Usage

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

### Examples

```bash
node darkfantasyartgenerator.js "a cursed knight kneeling before a shattered altar in a ruined cathedral" --token YOUR_TOKEN

node darkfantasyartgenerator.js "eldritch leviathan rising from a black ocean beneath a blood moon" --size landscape --token YOUR_TOKEN

node darkfantasyartgenerator.js "haunted gothic castle on a jagged cliff, swirling mist, ravens" --size tall --token YOUR_TOKEN
```

### Output

Returns a direct image URL.

## Options

| Flag | Description | Default |
|------|-------------|---------|
| `--size` | Image aspect: `portrait`, `landscape`, `square`, `tall` | `portrait` |
| `--token` | Your Neta API token (required) | — |
| `--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. Pass it via the `--token` flag:

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

You can also use shell expansion to keep the token out of your command history:

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

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


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

const DEFAULT_PROMPT = "dark fantasy art, ominous moody atmosphere, volumetric fog, dramatic chiaroscuro lighting, intricate gothic detail, ancient ruins and eldritch creatures, painterly oil texture, desaturated palette with deep crimson and cold blue accents, grimdark epic cinematic composition";

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 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);
  }
  if (positional.length > 0) args.prompt = positional.join(' ');
  return args;
}

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

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

  const PROMPT = promptArg && promptArg.trim().length > 0 ? 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);
  }

  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 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✗ Failed to create task: createRes.status createRes.statusText`);
    console.error(text);
    process.exit(1);
  }

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

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

  for (let attempt = 0; attempt < 90; attempt++) {
    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;

    let url = null;
    if (Array.isArray(data.artifacts) && data.artifacts[0]?.url) {
      url = data.artifacts[0].url;
    } else if (data.result_image_url) {
      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.`);
    console.error(JSON.stringify(data, null, 2));
    process.exit(1);
  }

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

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

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

---
name: surreal-art-generator
description: Generate jaw-dropping surreal AI art — Dali-style melting clocks, Magritte-inspired floating objects, dreamlike landscapes, absurdist scenes, impossible architecture, and bizarre creature mashups. Perfect for viral social posts, album covers, gallery prints, concept art, and TikTok-friendly weird-internet aesthetics. Supports surrealism, dream art, absurd imagery, dadaism, and abstract surreal styles via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Surreal Art Generator

Generate jaw-dropping surreal AI art — Dali-style melting clocks, Magritte-inspired floating objects, dreamlike landscapes, absurdist scenes, impossible architecture, and bizarre creature mashups. Perfect for viral social posts, album covers, gallery prints, concept art, and TikTok-friendly weird-internet aesthetics. Supports surrealism, dream art, absurd imagery, dadaism, and abstract surreal styles.

## Token

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

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

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

## Quick start
```bash
node surrealartgenerator.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 omactiengartelle/surreal-art-generator
```

FILE:README.md
# Surreal Art Generator

Generate jaw-dropping surreal AI art from text descriptions — Dali-style melting clocks, Magritte-inspired floating objects, dreamlike landscapes, absurdist scenes, impossible architecture, and bizarre creature mashups. Just describe the scene you want and the skill renders it as a high-resolution image. Perfect for viral social posts, album covers, gallery prints, concept art, and TikTok-friendly weird-internet aesthetics.

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

## Install

```bash
npx skills add omactiengartelle/surreal-art-generator
```

Or with ClawHub:

```bash
clawhub install surreal-art-generator
```

## Usage

```bash
node surrealartgenerator.js "a giraffe wearing a tuxedo riding a bicycle through Times Square" --token YOUR_TOKEN
```

More examples:

```bash
# Melting cathedral on the moon
node surrealartgenerator.js "a melting gothic cathedral floating above the lunar surface" --token YOUR_TOKEN

# Landscape orientation
node surrealartgenerator.js "an ocean of clouds with whales swimming through skyscrapers" --size landscape --token YOUR_TOKEN

# Style inheritance from a reference image
node surrealartgenerator.js "a clockwork octopus in a victorian library" --ref 9c1f3a2b-... --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| (positional) | The text prompt describing the surreal scene | — |
| `--size` | Image size: `square`, `portrait`, `landscape`, `tall` | `square` |
| `--token` | Your Neta API token | required |
| `--ref` | Reference image UUID for style inheritance | none |

### Sizes

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

## Output

Returns a direct image URL.

## Token setup

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

Pass the token to the script with the `--token` flag:

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

You can also expand it from a shell variable:

```bash
node surrealartgenerator.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":"surreal-art-generator","version":"1.0.0","type":"module","description":"Surreal Art Generator — AI-powered surreal art generator","license":"MIT"}

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

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_PROMPT = 'surreal dreamlike scene, absurd and imaginative composition, impossible physics, melting forms, floating objects, vivid otherworldly colors, hyper-detailed, dali-inspired, magritte-inspired, cinematic lighting, high resolution';

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.startsWith('--') && args.prompt === null) { args.prompt = a; }
  }
  return args;
}

async function main() {
  const { prompt: userPrompt, 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 = userPrompt && userPrompt.trim().length > 0
    ? `userPrompt, DEFAULT_PROMPT`
    : DEFAULT_PROMPT;

  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 (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.trim().replace(/^"|"$/g, '');
  }

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

  console.error(`→ Task taskUuid queued. 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) {
      const t = await pollRes.text();
      console.error(`✗ Poll failed: pollRes.status t`);
      process.exit(1);
    }
    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(`✗ Task ended (status) without an image URL.`);
    console.error(JSON.stringify(data, null, 2));
    process.exit(1);
  }

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

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

---
name: y2k-aesthetic-generator
description: Y2K aesthetic generator for nostalgic early-2000s and 2010s throwback photos — recreate the viral '2026 is the new 2016' trend with flash-photography selfies, Snapchat-era looks, low-res iPhone vibes, butterfly clips, frosted makeup, and dreamy mall-photo nostalgia. Perfect for TikTok, Instagram Reels, profile pics, retro fashion moodboards, Y2K party invites, nostalgia core content, and 2000s/2010s aesthetic edits via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Y2K Aesthetic Generator

Y2K aesthetic generator for nostalgic early-2000s and 2010s throwback photos — recreate the viral '2026 is the new 2016' trend with flash-photography selfies, Snapchat-era looks, low-res iPhone vibes, butterfly clips, frosted makeup, and dreamy mall-photo nostalgia. Perfect for TikTok, Instagram Reels, profile pics, retro fashion moodboards, Y2K party invites, nostalgia core content, and 2000s/2010s aesthetic edits.

## 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 y2k aesthetic photo generator images.

## Quick start
```bash
node y2kaestheticgenerator.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 omactiengartelle/y2k-aesthetic-generator
```

FILE:README.md
# Y2K Aesthetic Generator

Generate nostalgic early-2000s and 2010s throwback images from text descriptions. Recreate the viral "2026 is the new 2016" trend with flash-photography selfies, Snapchat-era looks, low-res iPhone vibes, butterfly clips, frosted makeup, and dreamy mall-photo nostalgia — all from a prompt. Great for TikTok, Instagram Reels, profile pics, retro fashion moodboards, Y2K party invites, and nostalgia-core content.

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

## Install

```bash
npx skills add omactiengartelle/y2k-aesthetic-generator
```

Or via ClawHub:

```bash
clawhub install y2k-aesthetic-generator
```

## Usage

```bash
node y2kaestheticgenerator.js "Y2K aesthetic portrait, butterfly clips, frosted lip gloss, mall photo booth" --token YOUR_TOKEN
```

With a reference image UUID:

```bash
node y2kaestheticgenerator.js "early 2000s flash selfie, low-rise denim" --token YOUR_TOKEN --ref <picture_uuid>
```

Different size:

```bash
node y2kaestheticgenerator.js "2000s digital camera candid pose" --size landscape --token YOUR_TOKEN
```

## Options

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

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

## Example

```bash
node y2kaestheticgenerator.js "Y2K aesthetic portrait, early 2000s flash, butterfly clips, frosted lip gloss, chunky sneakers, mall photo booth vibe" --token YOUR_TOKEN
```

Returns a direct image URL.


FILE:package.json
{"name":"y2k-aesthetic-generator","version":"1.0.0","type":"module","description":"Y2K Aesthetic Generator — AI-powered y2k aesthetic photo generator","license":"MIT"}

FILE:y2kaestheticgenerator.js
#!/usr/bin/env node
// Y2K Aesthetic Generator — Neta AI image generation CLI

const DEFAULT_PROMPT = "Y2K aesthetic portrait, early 2000s digital camera flash photography, slightly overblown highlights, low-res nostalgic quality, vibrant saturated colors, butterfly clips, frosted lip gloss, low-rise denim, chunky sneakers, candid pose, 2000s mall photo booth vibe, soft grain, nostalgic dreamy 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 = { prompt: null, size: "portrait", 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 (!a.startsWith("--") && args.prompt === null) { args.prompt = a; }
  }
  return args;
}

function printHelp() {
  console.log(`Y2K Aesthetic Generator

Usage:
  node y2kaestheticgenerator.js "<prompt>" [options]

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

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

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().catch(() => "");
    throw new Error(`make_image failed: res.status res.statusText 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 response: JSON.stringify(data)`);
  }
  const text = (await res.text()).trim().replace(/^"|"$/g, "");
  if (!text) throw new Error("Empty task_uuid response");
  return text;
}

async function pollTask({ token, taskUuid }) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  for (let attempt = 0; attempt < 90; attempt++) {
    await new Promise(r => setTimeout(r, 2000));
    const res = await fetch(url, {
      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 artifactUrl =
      (data.artifacts && data.artifacts[0] && data.artifacts[0].url) ||
      data.result_image_url;
    if (artifactUrl) return artifactUrl;
    throw new Error(`Task ended without image. Status: status. Response: JSON.stringify(data)`);
  }
  throw new Error("Timed out waiting for image (180s)");
}

async function main() {
  const args = parseArgs(process.argv);
  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 PROMPT = args.prompt || DEFAULT_PROMPT;
  const sizeKey = (args.size || "portrait").toLowerCase();
  const dims = SIZES[sizeKey];
  if (!dims) {
    console.error(`✗ Invalid --size: args.size. Use one of: Object.keys(SIZES).join(", ")`);
    process.exit(1);
  }

  try {
    const taskUuid = await createTask({
      token: TOKEN,
      prompt: PROMPT,
      width: dims.width,
      height: dims.height,
      ref: args.ref,
    });
    const imageUrl = await pollTask({ token: TOKEN, taskUuid });
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error(`✗ err.message || err`);
    process.exit(1);
  }
}

main();

---
name: pet-to-human-generator
description: your dog, cat, or any pet into a realistic human portrait with AI. Pet-to-human generator, humanize your pet, dog as a person, cat as human, animal-to-person art, pet human version, pet portrait transformation, viral pet trend generator — turn your furry friend into their human alter ego via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Pet To Human Generator

your dog, cat, or any pet into a realistic human portrait with AI. Pet-to-human generator, humanize your pet, dog as a person, cat as human, animal-to-person art, pet human version, pet portrait transformation, viral pet trend generator — turn your furry friend into their human alter ego.

## 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 to human ai generator images.

## Quick start
```bash
node pettohumangenerator.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 omactiengartelle/pet-to-human-generator
```

FILE:README.md
# Pet To Human Generator

Generate realistic human-portrait images from text descriptions of your pet. Describe your dog, cat, or any furry friend — their fur color, eye color, personality, vibe — and the skill produces a photorealistic human alter-ego portrait that preserves those traits. Perfect for the viral pet-to-human trend, creative portraits, gifts, and social media content.

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

## Install

```bash
npx skills add omactiengartelle/pet-to-human-generator
```

Or via ClawHub:

```bash
clawhub install pet-to-human-generator
```

## Usage

```bash
node pettohumangenerator.js "your text description" --token YOUR_TOKEN
```

### Examples

Generate a human version of a golden retriever:

```bash
node pettohumangenerator.js "golden retriever reimagined as a warm cheerful man with sandy blonde hair, hazel eyes, friendly smile, cozy knit sweater, studio lighting, photorealistic portrait" --token YOUR_TOKEN
```

Generate a human version of a black cat:

```bash
node pettohumangenerator.js "sleek black cat reimagined as a mysterious elegant woman with jet-black hair, green eyes, sharp cheekbones, minimalist black outfit, dramatic studio lighting" --token YOUR_TOKEN --size portrait
```

Use a reference picture UUID for style inheritance:

```bash
node pettohumangenerator.js "humanized tabby cat as a playful red-haired person" --token YOUR_TOKEN --ref 1234abcd-...-uuid
```

## Options

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

Size dimensions:

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

## Token setup

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

Pass it via the `--token` flag:

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

## Output

Returns a direct image URL. The script prints the URL to stdout on success — pipe it or copy it straight into your browser, download tool, or downstream workflow.

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

FILE:package.json
{"name":"pet-to-human-generator","version":"1.0.0","type":"module","description":"Pet To Human Generator — AI-powered pet to human ai generator","license":"MIT"}

FILE:pettohumangenerator.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 = "humanized version of a pet reimagined as a person, photorealistic portrait, preserving the pet's personality, fur color, eye color, and distinctive features translated into human appearance, expressive face, detailed clothing matching the pet's vibe, studio lighting, high detail";

function parseArgs(argv) {
  const args = { prompt: null, size: 'portrait', token: null, ref: 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;
}

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

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

const dims = SIZES[size];
if (!dims) {
  console.error(`✗ Invalid --size "size". Use: square, portrait, landscape, tall.`);
  process.exit(1);
}

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

async function submitTask() {
  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: HEADERS,
    body: JSON.stringify(body),
  });
  if (!res.ok) {
    const text = await res.text().catch(() => '');
    throw new Error(`make_image failed: res.status res.statusText 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 response: JSON.stringify(data)`);
  }
  const text = (await res.text()).trim().replace(/^"|"$/g, '');
  if (!text) throw new Error('Empty task_uuid response');
  return text;
}

async function pollTask(taskUuid) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  for (let attempt = 0; attempt < 90; attempt++) {
    await new Promise((r) => setTimeout(r, 2000));
    const res = await fetch(url, { headers: HEADERS });
    if (!res.ok) continue;
    const data = await res.json().catch(() => null);
    if (!data) continue;
    const status = data.task_status;
    if (status === 'PENDING' || status === 'MODERATION') continue;
    const artUrl = (Array.isArray(data.artifacts) && data.artifacts[0] && data.artifacts[0].url) || data.result_image_url;
    if (artUrl) return artUrl;
    throw new Error(`Task finished without URL: JSON.stringify(data)`);
  }
  throw new Error('Timed out waiting for task');
}

(async () => {
  try {
    const taskUuid = await submitTask();
    const imageUrl = await pollTask(taskUuid);
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error(`✗ err.message`);
    process.exit(1);
  }
})();

---
name: wedding-invitation-generator
description: Design elegant AI wedding invitations, save-the-dates, RSVP cards, bridal shower invites, and engagement announcements. Generate beautiful watercolor florals, botanical illustrations, minimalist modern layouts, rustic barn themes, romantic garden scenes, boho chic designs, classic gold-accented stationery, and custom wedding suite artwork for brides, grooms, wedding planners, stationery designers, and Etsy sellers via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Wedding Invitation Generator

Design elegant AI wedding invitations, save-the-dates, RSVP cards, bridal shower invites, and engagement announcements. Generate beautiful watercolor florals, botanical illustrations, minimalist modern layouts, rustic barn themes, romantic garden scenes, boho chic designs, classic gold-accented stationery, and custom wedding suite artwork for brides, grooms, wedding planners, stationery designers, and Etsy sellers.

## 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 wedding invitation design generator images.

## Quick start
```bash
node weddinginvitationgenerator.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 omactiengartelle/wedding-invitation-generator
```

FILE:README.md
# Wedding Invitation Generator

Design elegant AI wedding invitations, save-the-dates, RSVP cards, bridal shower invites, and engagement announcements from text descriptions. Generate beautiful watercolor florals, botanical illustrations, minimalist modern layouts, rustic barn themes, romantic garden scenes, boho chic designs, classic gold-accented stationery, and custom wedding suite artwork — all from a short prompt describing the style you want.

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

## Install

```bash
npx skills add omactiengartelle/wedding-invitation-generator
```

Or via ClawHub:

```bash
clawhub install wedding-invitation-generator
```

## Usage

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

### Examples

Generate an elegant watercolor floral invitation:

```bash
node weddinginvitationgenerator.js \
  "elegant wedding invitation design, soft watercolor botanical florals in blush pink and ivory, delicate gold foil accents, romantic garden aesthetic, cream paper texture" \
  --token YOUR_TOKEN
```

Minimalist modern save-the-date in landscape:

```bash
node weddinginvitationgenerator.js \
  "minimalist modern save-the-date card, clean typography, single sprig of eucalyptus, soft beige background, refined stationery" \
  --size landscape \
  --token YOUR_TOKEN
```

Rustic barn-themed engagement announcement with a reference image:

```bash
node weddinginvitationgenerator.js \
  "rustic barn wedding engagement announcement, warm earth tones, wildflowers, kraft paper texture, hand-lettered script" \
  --ref 123e4567-e89b-12d3-a456-426614174000 \
  --token YOUR_TOKEN
```

## Options

| Flag | Description | Default |
| --- | --- | --- |
| `<prompt>` (positional) | Text description of the invitation you want | built-in wedding prompt |
| `--size` | `portrait`, `landscape`, `square`, or `tall` | `portrait` |
| `--token` | Your Neta API token (required) | — |
| `--ref` | Reference image UUID for style inheritance | — |

### Size dimensions

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

## Output

Returns a direct image URL.

## Token setup

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

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

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

Shell expansion works if you prefer to keep the token in your shell session:

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

The `--token` flag is the only way to provide your token to this script.


FILE:package.json
{"name":"wedding-invitation-generator","version":"1.0.0","type":"module","description":"Wedding Invitation Generator — AI-powered ai wedding invitation design generator","license":"MIT"}

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

const DEFAULT_PROMPT = 'elegant wedding invitation design, soft watercolor botanical florals in blush pink and ivory, delicate gold foil accents, romantic garden aesthetic, sophisticated layout with space for typography, cream paper texture, refined and timeless, high-end stationery photography, soft natural light';

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('--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 (!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 task (dims.width×dims.height)...`);

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

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

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

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

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

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

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

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

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

    const status = data.task_status;
    if (status === 'PENDING' || status === 'MODERATION') {
      if (i % 5 === 0) console.error(`  [i + 1/maxAttempts] status`);
      continue;
    }

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

    if (url) {
      stdout.write(url + '\n');
      exit(0);
    }

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

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

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

---
name: pixar-portrait-generator
description: selfies and portraits into Pixar-style 3D animated characters with cinematic CGI rendering. Generate Disney Pixar movie-quality avatars, 3D cartoon portraits, and animated character art featuring soft volumetric lighting, expressive oversized eyes, and glossy subsurface skin — perfect for viral profile pictures, animated-style headshots, family portraits, and 3D cartoon transformations of people, pets, and original characters via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Pixar Portrait Generator

selfies and portraits into Pixar-style 3D animated characters with cinematic CGI rendering. Generate Disney Pixar movie-quality avatars, 3D cartoon portraits, and animated character art featuring soft volumetric lighting, expressive oversized eyes, and glossy subsurface skin — perfect for viral profile pictures, animated-style headshots, family portraits, and 3D cartoon transformations of people, pets, and original characters.

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

## Quick start
```bash
node pixarportraitgenerator.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 omactiengartelle/pixar-portrait-generator
```

FILE:README.md
# Pixar Portrait Generator

Generate Pixar-style 3D animated character portraits from text descriptions. Produces cinematic CGI-quality images with soft volumetric lighting, expressive oversized eyes, glossy subsurface skin, and warm vibrant colors — ideal for profile pictures, animated-style headshots, family portraits, and stylized character art.

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

## Install

```bash
npx skills add omactiengartelle/pixar-portrait-generator
```

Or with ClawHub:

```bash
clawhub install pixar-portrait-generator
```

## Usage

```bash
node pixarportraitgenerator.js "a cheerful young girl with curly red hair and freckles" --token YOUR_TOKEN
```

### More examples

```bash
# Square (default)
node pixarportraitgenerator.js "a wise old wizard with a long white beard" --token YOUR_TOKEN

# Portrait orientation
node pixarportraitgenerator.js "a happy golden retriever puppy" --token YOUR_TOKEN --size portrait

# Landscape with a reference image for style inheritance
node pixarportraitgenerator.js "a family of four at a picnic" --token YOUR_TOKEN --size landscape --ref <picture_uuid>
```

## Options

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

### Size dimensions

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

## Token setup

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

Pass it via the `--token` flag:

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

## Output

Returns a direct image URL on stdout. Progress messages are written to stderr, so you can safely pipe the URL:

```bash
URL=$(node pixarportraitgenerator.js "a brave astronaut cat" --token "$NETA_TOKEN")
echo "$URL"
```


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

FILE:pixarportraitgenerator.js
#!/usr/bin/env node
// Pixar Portrait Generator — Neta AI image generation CLI

const DEFAULT_PROMPT = "Pixar-style 3D animated character portrait, cinematic CGI rendering, soft volumetric lighting, expressive oversized eyes, smooth glossy subsurface skin, warm vibrant colors, shallow depth of field, studio quality 3D animation, family-friendly wholesome aesthetic, detailed facial features with subtle texture, professional Pixar movie character design";

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: "square", 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 args.positional.push(a);
  }
  return args;
}

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

  const PROMPT = positional[0] || 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);
  }

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

  console.error(`→ Submitting task (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`,
      { 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") {
      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 but no image URL. Status: status`);
    console.error(JSON.stringify(data, null, 2));
    process.exit(1);
  }

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

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

---
name: film-photo-generator
description: Generate authentic analog-style film photographs with 35mm grain, light leaks, and faded retro color palettes. Perfect for nostalgic portraits, vintage 70s/80s aesthetic photos, Instagram film looks, Kodak Portra style imagery, lomography effects, Fujifilm simulation, and imperfect human photography that beats the polished AI look — ideal for indie creators, film photography enthusiasts, and retro mood boards via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Film Photo Generator

Generate authentic analog-style film photographs with 35mm grain, light leaks, and faded retro color palettes. Perfect for nostalgic portraits, vintage 70s/80s aesthetic photos, Instagram film looks, Kodak Portra style imagery, lomography effects, Fujifilm simulation, and imperfect human photography that beats the polished AI look — ideal for indie creators, film photography enthusiasts, and retro mood boards.

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

## Quick start
```bash
node filmphotogenerator.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 omactiengartelle/film-photo-generator
```

FILE:README.md
# Film Photo Generator

Generate authentic analog-style film photographs from text descriptions — complete with 35mm grain, soft light leaks, faded color palettes, and that nostalgic 70s/80s vibe. Perfect for indie creators, film photography enthusiasts, and anyone tired of the polished AI look.

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

## Install

```bash
npx skills add omactiengartelle/film-photo-generator
```

Or via ClawHub:

```bash
clawhub install film-photo-generator
```

## Token Setup

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

Pass it via the `--token` flag:

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

## Usage

### Basic example

```bash
node filmphotogenerator.js "young woman laughing in a sunlit kitchen" --token YOUR_TOKEN
```

### Landscape orientation

```bash
node filmphotogenerator.js "empty diner at golden hour" --size landscape --token YOUR_TOKEN
```

### With a reference image for style inheritance

```bash
node filmphotogenerator.js "portrait of a man on a beach" --ref PICTURE_UUID --token YOUR_TOKEN
```

### Default prompt

If you omit the prompt, the skill uses a curated film-look default:

> analog film photograph, 35mm film grain, soft light leaks, faded color palette, muted contrast, nostalgic 1970s 1980s aesthetic, vintage kodak portra film stock, subtle vignette, authentic imperfect photography, shot on film camera, cinematic warm tones

## Options

| Flag      | Description                                                      | Default    |
| --------- | ---------------------------------------------------------------- | ---------- |
| `--token` | Your Neta API token (required)                                   | —          |
| `--size`  | Image orientation: `portrait`, `landscape`, `square`, or `tall`  | `portrait` |
| `--ref`   | Reference image UUID to inherit style from                       | none       |

### Size dimensions

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

## Output

Returns a direct image URL.


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

const DEFAULT_PROMPT = 'analog film photograph, 35mm film grain, soft light leaks, faded color palette, muted contrast, nostalgic 1970s 1980s aesthetic, vintage kodak portra film stock, subtle vignette, authentic imperfect photography, shot on film camera, cinematic warm tones';

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 === '--help' || a === '-h') {
      console.log('Usage: node filmphotogenerator.js "prompt" --token YOUR_TOKEN [--size portrait|landscape|square|tall] [--ref picture_uuid]');
      process.exit(0);
    } else args.positional.push(a);
  }
  return args;
}

const args = parseArgs(process.argv.slice(2));
const PROMPT = args.positional[0] || 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 || 'portrait').toLowerCase();
const size = SIZES[sizeKey];
if (!size) {
  console.error(`✗ Invalid size "args.size". Use: square, portrait, landscape, tall`);
  process.exit(1);
}

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

async function submitJob() {
  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,
    };
  }

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

  if (!res.ok) {
    const text = await res.text();
    throw new Error(`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;
    return String(data).replace(/"/g, '').trim();
  }

  const text = await res.text();
  return text.replace(/"/g, '').trim();
}

async function pollTask(taskUuid) {
  const maxAttempts = 90;
  for (let i = 0; i < maxAttempts; i++) {
    await new Promise((r) => setTimeout(r, 2000));
    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/taskUuid`, {
      headers: HEADERS,
    });
    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 ended without image. Status: status`);
  }
  throw new Error('Timed out waiting for image');
}

(async () => {
  try {
    console.error(`→ Submitting (size.width×size.height)...`);
    const taskUuid = await submitJob();
    console.error(`→ Task: taskUuid`);
    console.error('→ Polling...');
    const url = await pollTask(taskUuid);
    console.log(url);
    process.exit(0);
  } catch (err) {
    console.error(`✗ err.message`);
    process.exit(1);
  }
})();

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

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

# D&D Character Art Generator

Generate stunning dnd character art 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 dnd character art generator images.

## Quick start
```bash
node dndcharacter.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 omactiengartelle/dnd-character-skill
```

FILE:README.md
# D&D Character Art Generator

Generate stunning D&D character art from text descriptions. Describe your character — race, class, armor, weapons, pose — and get back a high-quality fantasy portrait powered by AI image generation.

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

## Install

```bash
npx skills add omactiengartelle/dnd-character-skill
```

or

```bash
clawhub install dnd-character-skill
```

## Usage

```bash
node dndcharacter.js "dungeons and dragons character portrait, fantasy RPG art, detailed armor and weapons" --token YOUR_TOKEN
```

Returns a direct image URL.

### With options

```bash
# Landscape format
node dndcharacter.js "elven ranger in a moonlit forest, longbow drawn" --token "$NETA_TOKEN" --size landscape

# Square format with a reference image
node dndcharacter.js "dwarf paladin in gleaming plate armor, warhammer raised" --token "$NETA_TOKEN" --size square --ref abc123-uuid
```

Returns a direct image URL.

## Options

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

## Token Setup

Get a free trial Neta API token at [neta.art/open](https://www.neta.art/open/).

Pass your token using the `--token` flag:

```bash
node dndcharacter.js "half-orc barbarian with a greataxe" --token YOUR_TOKEN
```

You can also use shell variable expansion for convenience:

```bash
export NETA_TOKEN="your-token-here"
node dndcharacter.js "tiefling warlock with eldritch energy" --token "$NETA_TOKEN"
```

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

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

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

function getFlag(name) {
  const idx = args.indexOf(name);
  if (idx !== -1 && idx + 1 < args.length) return args[idx + 1];
  return null;
}

const prompt = args.find(a => !a.startsWith('--') && (args.indexOf(a) === 0 || !['--size', '--token', '--ref'].includes(args[args.indexOf(a) - 1])));
const sizeFlag = getFlag('--size') || 'portrait';
const tokenFlag = getFlag('--token');
const refFlag = getFlag('--ref');

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 dndcharacter.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 size = SIZES[sizeFlag];
if (!size) {
  console.error(`\n\u2717 Invalid size "sizeFlag". Choose: square, portrait, landscape, tall`);
  process.exit(1);
}

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

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

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

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

  const data = await res.json().catch(() => null);
  let taskUuid;
  if (typeof data === 'string') {
    taskUuid = data;
  } else if (data && data.task_uuid) {
    taskUuid = data.task_uuid;
  } else {
    const text = await res.text().catch(() => '');
    taskUuid = text || data;
  }

  if (!taskUuid) {
    console.error('\n\u2717 No task UUID returned from API');
    process.exit(1);
  }

  return taskUuid;
}

async function pollResult(taskUuid) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  const MAX_ATTEMPTS = 90;
  const INTERVAL = 2000;

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

    const res = await fetch(url, { headers: HEADERS });
    if (!res.ok) continue;

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

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

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

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

    console.error('\n\u2717 Task completed but no image URL found in response');
    process.exit(1);
  }

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

const taskUuid = await createImage();
await pollResult(taskUuid);

FILE:package.json
{"name":"dnd-character-skill","version":"1.0.0","type":"module","description":"D&D Character Art Generator — AI-powered dnd character art generator","license":"MIT"}

---
name: 3d-anime-poster-generator
description: Create stunning 3D anime posters with volumetric lighting, cinematic depth, and dynamic compositions. Perfect for wallpapers, merch designs, print-on-demand art, anime fan posters, cyberpunk-style artwork, and decorative prints. AI-powered 3D anime art poster maker and designer via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# 3D Anime Poster Generator

Create stunning 3D anime posters with volumetric lighting, cinematic depth, and dynamic compositions. Perfect for wallpapers, merch designs, print-on-demand art, anime fan posters, cyberpunk-style artwork, and decorative prints. AI-powered 3D anime art poster maker and 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 3d anime poster generator images.

## Quick start
```bash
node 3danimepostergenerator.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 omactiengartelle/3d-anime-poster-generator
```

FILE:3danimepostergenerator.js
#!/usr/bin/env node

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

// Parse CLI arguments
let prompt = null;
let size = "portrait";
let token = null;
let ref = null;

for (let i = 0; i < args.length; i++) {
  if (args[i] === "--token" && i + 1 < args.length) {
    token = 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 = token;

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) {
  prompt =
    "3D anime poster, volumetric lighting, cinematic depth of field, vibrant colors, dynamic composition, detailed character art, cyberpunk-infused atmosphere, dramatic scene layout, high detail rendering";
}

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",
};

async function createImage() {
  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(`Creating 3D anime poster (size chosen.widthxchosen.height)...`);
  console.error(`Prompt: prompt`);

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

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

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

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

  console.error(`Task UUID: 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: 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 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("\u2717 Task completed but no image URL found");
      console.error(JSON.stringify(pollData));
      process.exit(1);
    }
  }

  console.error("\u2717 Timed out waiting for image (180s)");
  process.exit(1);
}

createImage();

FILE:README.md
# 3D Anime Poster Generator

Generate stunning 3D anime posters from text descriptions with volumetric lighting, cinematic depth of field, and dynamic compositions. Perfect for wallpapers, merch designs, print-on-demand art, anime fan posters, cyberpunk-style artwork, and decorative prints.

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

## Install

```bash
npx skills add omactiengartelle/3d-anime-poster-generator
```

or

```bash
clawhub install 3d-anime-poster-generator
```

## Token Setup

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

Pass it via the `--token` flag:

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

## Usage

Generate a 3D anime poster with the default style:

```bash
node 3danimepostergenerator.js "cyberpunk samurai standing on a neon rooftop at night" --token YOUR_TOKEN
```

Generate a landscape poster:

```bash
node 3danimepostergenerator.js "epic mecha battle in a ruined city, sunset lighting" --size landscape --token YOUR_TOKEN
```

Use a reference image UUID for style inheritance:

```bash
node 3danimepostergenerator.js "warrior princess in enchanted forest" --ref PICTURE_UUID --token YOUR_TOKEN
```

## Output

Returns a direct image URL.

## Options

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

### Size Details

| 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:package.json
{"name":"3d-anime-poster-generator","version":"1.0.0","type":"module","description":"3D Anime Poster Generator — AI-powered 3d anime poster generator","license":"MIT"}

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

# Waifu Generator

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

## Quick start
```bash
node waifugen.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 omactiengartelle/waifu-gen-skill
```

FILE:README.md
# Waifu Generator

Generate waifu and anime-style images from text descriptions using AI. Describe the character you want and get back a direct image URL instantly.

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

## Install

```bash
npx skills add omactiengartelle/waifu-gen-skill
```

Or via ClawHub:

```bash
clawhub install waifu-gen-skill
```

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

Basic generation with default portrait size:

```bash
node waifugen.js "anime waifu character, beautiful illustration, detailed artwork" --token YOUR_TOKEN
```

Generate a landscape image:

```bash
node waifugen.js "anime girl in a flower field, sunset background" --size landscape --token YOUR_TOKEN
```

Use a reference image UUID for style inheritance:

```bash
node waifugen.js "elegant waifu, flowing hair, fantasy style" --ref PICTURE_UUID --token YOUR_TOKEN
```

Returns a direct image URL.

## Options

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

### Size Dimensions

| Size | Width | Height |
|------|-------|--------|
| `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:package.json
{"name":"waifu-gen-skill","version":"1.0.0","type":"module","description":"Waifu Generator — AI-powered waifu generator ai","license":"MIT"}

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

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

// Parse CLI arguments
let prompt = null;
let size = "portrait";
let token = null;
let ref = null;

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

const TOKEN = token;

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 waifugen.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: 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 createImage() {
  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(`\n\u2717 Image creation failed (res.status): text`);
    process.exit(1);
  }

  const data = await res.json().catch(() => null);
  let taskUuid;

  if (typeof data === "string") {
    taskUuid = data;
  } else if (data && data.task_uuid) {
    taskUuid = data.task_uuid;
  } else {
    const text = await res.text().catch(() => "");
    taskUuid = text || data;
  }

  if (!taskUuid) {
    console.error("\n\u2717 No task UUID returned from API.");
    process.exit(1);
  }

  return taskUuid;
}

async function pollResult(taskUuid) {
  const pollUrl = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  const maxAttempts = 90;

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

    const res = await fetch(pollUrl, { headers });
    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) {
      console.log(url);
      process.exit(0);
    } else {
      console.error("\n\u2717 Task completed but no image URL found.");
      console.error(JSON.stringify(data, null, 2));
      process.exit(1);
    }
  }

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

console.error(`Generating image (size dimensions.widthxdimensions.height)...`);
const taskUuid = await createImage();
console.error(`Task started: taskUuid`);
await pollResult(taskUuid);

---
name: movie-poster-generator
description: Create stunning AI movie posters, film posters, and cinema artwork. Generate professional movie poster designs, event posters, fan-made film posters, and theatrical promotional art with dramatic cinematic lighting and bold compositions via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Movie Poster Generator

Create stunning AI movie posters, film posters, and cinema artwork. Generate professional movie poster designs, event posters, fan-made film posters, and theatrical promotional art with dramatic cinematic lighting and bold compositions.

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

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

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

## Install
```bash
npx skills add omactiengartelle/movie-poster-generator
```

FILE:README.md
# Movie Poster Generator

Generate stunning AI movie posters, film posters, and cinema artwork from text descriptions. Create professional movie poster designs, event posters, fan-made film posters, and theatrical promotional art with dramatic cinematic lighting and bold compositions.

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

## Install

```bash
npx skills add omactiengartelle/movie-poster-generator
```

or

```bash
clawhub install movie-poster-generator
```

## Usage

```bash
node moviepostergenerator.js "cinematic movie poster, dramatic lighting, bold composition" --token YOUR_TOKEN
```

Generate a tall poster (default):

```bash
node moviepostergenerator.js "epic sci-fi movie poster with a lone astronaut facing a distant galaxy, dramatic lighting" --token YOUR_TOKEN
```

Generate a landscape poster:

```bash
node moviepostergenerator.js "noir detective thriller poster, rain-soaked city streets, moody shadows" --token YOUR_TOKEN --size landscape
```

Use a reference image for style inheritance:

```bash
node moviepostergenerator.js "horror movie poster, abandoned mansion, fog" --token YOUR_TOKEN --ref PICTURE_UUID
```

Returns a direct image URL.

## Options

| Option    | Description                          | Default |
|-----------|--------------------------------------|---------|
| `--token` | Neta API token (required)            | —       |
| `--size`  | Image size preset                    | `tall`  |
| `--ref`   | Reference image UUID for style       | —       |

### Available sizes

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

## Token Setup

A Neta API token is required to use this skill. Get a free trial token at [neta.art/open](https://www.neta.art/open/).

Pass your token using the `--token` flag:

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

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

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

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

// Parse CLI arguments
let prompt = null;
let size = 'tall';
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 moviepostergenerator.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: portrait, landscape, square, 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(`\u2139 Generating movie poster (size: dimensions.widthxdimensions.height)...`);
  console.error(`\u2139 Prompt: "prompt"`);

  // 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 API error (createRes.status): errText`);
    process.exit(1);
  }

  const createData = await createRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(createData);
    taskUuid = parsed.task_uuid || parsed;
  } catch {
    taskUuid = createData.replace(/"/g, '').trim();
  }

  if (!taskUuid) {
    console.error('\n\u2717 No task UUID returned from API.');
    process.exit(1);
  }

  console.error(`\u2139 Task UUID: taskUuid`);
  console.error('\u2139 Polling for result...');

  // Poll for completion
  const maxAttempts = 90;
  const pollInterval = 2000;

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

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

    if (!pollRes.ok) {
      console.error(`\u2139 Poll attempt attempt/maxAttempts — HTTP pollRes.status, retrying...`);
      continue;
    }

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

    if (status === "PENDING" || status === "MODERATION") {
      console.error(`\u2139 Poll attempt attempt/maxAttempts — status: 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(JSON.stringify(pollData, null, 2));
      process.exit(1);
    }
  }

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

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

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

---
name: kpop-idol-generator
description: Generate k-pop idol style portraits and kpop photocard aesthetic images — perfect for kpop fan edits, korean beauty looks, idol photoshoot vibes, korean fashion portraits, stan twitter profile pics, kpop bias card art, and hallyu-inspired glamour photography. Turn any description into a polished k-pop idol debut photo via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# K-Pop Idol Generator

Generate k-pop idol style portraits and kpop photocard aesthetic images — perfect for kpop fan edits, korean beauty looks, idol photoshoot vibes, korean fashion portraits, stan twitter profile pics, kpop bias card art, and hallyu-inspired glamour photography. Turn any description into a polished k-pop idol debut photo.

## 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 kpop idol style portrait images.

## Quick start
```bash
node kpopidolgenerator.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 omactiengartelle/kpop-idol-generator
```

FILE:README.md
# K-Pop Idol Generator

Generate polished k-pop idol style portraits from plain text descriptions. Describe the look you want — hair color, outfit, mood, setting — and the skill renders a glossy, magazine-quality idol photo with korean beauty aesthetics, dewy skin, designer styling, and cinematic studio lighting. Perfect for kpop fan edits, bias photocard art, stan twitter profile pics, korean fashion portraits, and hallyu-inspired glamour photography.

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

## Install

Install via ClawHub / OpenClaw:

```bash
npx skills add omactiengartelle/kpop-idol-generator
```

Or with the ClawHub CLI:

```bash
clawhub install kpop-idol-generator
```

## Usage

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

### Examples

Generate a classic idol portrait:

```bash
node kpopidolgenerator.js "young woman with pastel pink hair smiling softly" --token "$NETA_TOKEN"
```

Generate a landscape concept photo:

```bash
node kpopidolgenerator.js "boy group member in oversized varsity jacket, neon city backdrop" \
  --token "$NETA_TOKEN" --size landscape
```

Generate a square photocard-style shot:

```bash
node kpopidolgenerator.js "girl group visual in sparkling silver stage outfit" \
  --token "$NETA_TOKEN" --size square
```

Use a reference image for style inheritance:

```bash
node kpopidolgenerator.js "rookie idol debut teaser, dreamy pastel tones" \
  --token "$NETA_TOKEN" --ref <picture_uuid>
```

## Options

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

### Size reference

| 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. On success, the URL is printed to stdout so you can pipe it, open it, or download it:

```bash
IMG=$(node kpopidolgenerator.js "idol visual center with wavy blonde hair" --token "$NETA_TOKEN")
echo "$IMG"
```

Progress messages are written to stderr so they don't pollute the captured output.

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

FILE:kpopidolgenerator.js
#!/usr/bin/env node
// K-Pop Idol Generator — generates k-pop idol style portraits via the Neta AI API.

const DEFAULT_PROMPT_SUFFIX = "k-pop idol style portrait, glossy studio lighting, korean beauty aesthetic, flawless dewy skin, trendy designer outfit, colored contacts, styled hair, glamorous magazine-quality photography, soft gradient background, high fashion pose, cinematic bokeh";

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(`K-Pop Idol Generator

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

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

Example:
  node kpopidolgenerator.js "young woman with pastel pink hair smiling" --token "$NETA_TOKEN"
`);
}

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().catch(() => "");
    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 || parsed.taskUuid);
  } catch {
    taskUuid = raw.replace(/^"|"$/g, "").trim();
  }
  if (!taskUuid) throw new Error(`No task_uuid in response: raw`);
  return taskUuid;
}

async function pollTask({ token, taskUuid }) {
  const url = `https://api.talesofai.com/v1/artifact/task/taskUuid`;
  const headers = {
    "x-token": token,
    "x-platform": "nieta-app/web",
    "content-type": "application/json",
  };

  for (let attempt = 0; attempt < 90; attempt++) {
    await new Promise((r) => setTimeout(r, 2000));
    const res = await fetch(url, { headers });
    if (!res.ok) continue;
    const data = await res.json().catch(() => null);
    if (!data) continue;

    const status = data.task_status;
    if (status === "PENDING" || status === "MODERATION") continue;

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

    throw new Error(`Task finished with status status but no image URL. Response: JSON.stringify(data)`);
  }
  throw new Error("Timed out waiting for image generation (180s).");
}

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 kpopidolgenerator.js "your prompt" --token YOUR_TOKEN');
    process.exit(1);
  }

  const sizeKey = (args.size || "portrait").toLowerCase();
  const size = SIZES[sizeKey];
  if (!size) {
    console.error(`✗ Unknown size "sizeKey". Use one of: Object.keys(SIZES).join(", ")`);
    process.exit(1);
  }

  const PROMPT = `userPrompt, DEFAULT_PROMPT_SUFFIX`;

  try {
    console.error(`→ Submitting generation task (sizeKey size.widthxsize.height)...`);
    const taskUuid = await createTask({
      token: TOKEN,
      prompt: PROMPT,
      width: size.width,
      height: size.height,
      ref: args.ref,
    });
    console.error(`→ Task taskUuid queued. Polling...`);
    const imageUrl = await pollTask({ token: TOKEN, taskUuid });
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error(`\n✗ err.message || err`);
    process.exit(1);
  }
}

main();

FILE:package.json
{"name":"kpop-idol-generator","version":"1.0.0","type":"module","description":"K-Pop Idol Generator — AI-powered kpop idol style portrait ai","license":"MIT"}

---
name: magazine-cover-generator
description: Generate stunning AI magazine cover art in Vogue, TIME, GQ, and editorial styles. Perfect for fashion covers, lifestyle magazine mockups, parody covers, personal branding, social media viral posts, pet magazine covers, and mixed-media editorial collage designs with professional masthead typography and cover headlines via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Magazine Cover Generator

Generate stunning AI magazine cover art in Vogue, TIME, GQ, and editorial styles. Perfect for fashion covers, lifestyle magazine mockups, parody covers, personal branding, social media viral posts, pet magazine covers, and mixed-media editorial collage designs with professional masthead typography and cover headlines.

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

## Quick start
```bash
node magazinecovergenerator.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 omactiengartelle/magazine-cover-generator
```

FILE:README.md
# Magazine Cover Generator

Generate stunning AI magazine cover art from text descriptions in Vogue, TIME, GQ, and editorial styles. Perfect for fashion covers, lifestyle magazine mockups, parody covers, personal branding, social media viral posts, pet magazine covers, and mixed-media editorial collage designs with professional masthead typography and cover headlines — all produced from a simple text prompt, with no photos or uploads required.

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

## Install

```bash
npx skills add omactiengartelle/magazine-cover-generator
```

Or via ClawHub:

```bash
clawhub install magazine-cover-generator
```

## Usage

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

### Examples

Generate a fashion cover:

```bash
node magazinecovergenerator.js "confident woman in red blazer, city skyline background" --token YOUR_TOKEN
```

Generate a TIME-style person of the year cover:

```bash
node magazinecovergenerator.js "tech visionary portrait, black and white, bold red border" --token YOUR_TOKEN
```

Generate a pet magazine cover:

```bash
node magazinecovergenerator.js "golden retriever wearing sunglasses, summer issue" --token YOUR_TOKEN
```

Landscape cover layout:

```bash
node magazinecovergenerator.js "surreal collage, mixed media" --size landscape --token YOUR_TOKEN
```

Use a reference image for style inheritance:

```bash
node magazinecovergenerator.js "editorial portrait" --ref <picture_uuid> --token YOUR_TOKEN
```

## Options

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

### Sizes

| 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:magazinecovergenerator.js
#!/usr/bin/env node
// Magazine Cover Generator — AI magazine cover art generator
// Powered by the Neta AI image generation API (api.talesofai.com)

const DEFAULT_PROMPT_SUFFIX = "high-fashion editorial magazine cover, bold masthead typography, dramatic lighting, professional photography, glossy finish, cover headlines, barcode, issue date, Vogue TIME GQ style layout, mixed-media collage elements, editorial composition";

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 = { prompt: null, size: "portrait", token: null, ref: null };
  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 if (a === "--help" || a === "-h") { args.help = true; }
    else { positional.push(a); }
  }
  if (positional.length > 0) args.prompt = positional.join(" ");
  return args;
}

function printHelp() {
  console.log(`Magazine Cover Generator

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

Options:
  --size <size>    portrait | landscape | square | tall (default: portrait)
  --token <token>  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

Example:
  node magazinecovergenerator.js "astronaut on vogue cover" --token YOUR_TOKEN
`);
}

async function createTask(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().catch(() => "");
    throw new Error(`make_image failed: res.status res.statusText text`);
  }

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

async function pollTask(token, task_uuid) {
  const maxAttempts = 90;
  for (let i = 0; i < maxAttempts; i++) {
    const res = await fetch(`https://api.talesofai.com/v1/artifact/task/task_uuid`, {
      headers: {
        "x-token": token,
        "x-platform": "nieta-app/web",
        "content-type": "application/json",
      },
    });
    if (!res.ok) {
      await new Promise(r => setTimeout(r, 2000));
      continue;
    }
    const data = await res.json();
    const status = data.task_status;
    if (status === "PENDING" || status === "MODERATION") {
      await new Promise(r => setTimeout(r, 2000));
      continue;
    }
    // Done
    if (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 finished but no image URL: JSON.stringify(data)`);
  }
  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);
  }

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

  const fullPrompt = `args.prompt, DEFAULT_PROMPT_SUFFIX`;

  try {
    const task_uuid = await createTask(TOKEN, fullPrompt, args.size, args.ref);
    const imageUrl = await pollTask(TOKEN, task_uuid);
    console.log(imageUrl);
    process.exit(0);
  } catch (err) {
    console.error(`\n✗ err.message`);
    process.exit(1);
  }
}

main();

FILE:package.json
{
  "name": "magazine-cover-generator",
  "version": "1.0.1",
  "type": "module",
  "description": "Magazine Cover Generator — AI-powered ai magazine cover generator",
  "license": "MIT"
}

---
name: tarot-card-art-generator
description: Generate stunning AI tarot card art and mystical oracle deck illustrations. Create custom major and minor arcana designs, divination card artwork, spiritual deck imagery, occult-themed illustrations, and fortune card visuals with ornate borders and rich symbolism via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Tarot Card Art Generator

Generate stunning AI tarot card art and mystical oracle deck illustrations. Create custom major and minor arcana designs, divination card artwork, spiritual deck imagery, occult-themed illustrations, and fortune card visuals with ornate borders and rich symbolism.

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

## Quick start
```bash
node tarotcardartgenerator.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 omactiengartelle/tarot-card-art-generator
```

FILE:README.md
# Tarot Card Art Generator

Generate stunning AI tarot card art and mystical oracle deck illustrations from text descriptions. Create custom major and minor arcana designs, divination card artwork, spiritual deck imagery, occult-themed illustrations, and fortune card visuals with ornate borders and rich symbolism.

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

## Install

```bash
npx skills add omactiengartelle/tarot-card-art-generator
```

or

```bash
clawhub install tarot-card-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 tarot card with the default mystical style:

```bash
node tarotcardartgenerator.js "The High Priestess seated between two pillars, moonlight illuminating ancient scrolls, deep blue and silver palette" --token YOUR_TOKEN
```

Generate a landscape-oriented card:

```bash
node tarotcardartgenerator.js "The Fool stepping off a cliff into a field of stars, whimsical art nouveau style" --size landscape --token YOUR_TOKEN
```

Use a reference image for style inheritance:

```bash
node tarotcardartgenerator.js "The Tower struck by lightning, dramatic chiaroscuro" --ref PICTURE_UUID --token YOUR_TOKEN
```

Returns a direct image URL.

## Options

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

### Size Dimensions

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

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

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

FILE:tarotcardartgenerator.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 (!args[i].startsWith("--") && !prompt) {
    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) {
  prompt =
    "A beautifully illustrated tarot card with ornate golden border, mystical symbolism, rich jewel-tone colors, intricate details, dramatic lighting, esoteric imagery";
}

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

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

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

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(`Generating tarot card art (size dimensions.widthxdimensions.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`);

  // Poll for completion
  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;
    }

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

    if (url) {
      console.log(url);
      process.exit(0);
    } else {
      console.error("\u2717 No image URL in response");
      console.error(JSON.stringify(pollData));
      process.exit(1);
    }
  }

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

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

---
name: gothic-portrait-generator
description: Generate stunning gothic portraits with dark dramatic lighting, Victorian elegance, and moody atmosphere. Perfect for gothic art, dark fantasy portraits, horror aesthetic avatars, Victorian-style character art, dark academia profile pictures, and goth community content creation via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Gothic Portrait Generator

Generate stunning gothic portraits with dark dramatic lighting, Victorian elegance, and moody atmosphere. Perfect for gothic art, dark fantasy portraits, horror aesthetic avatars, Victorian-style character art, dark academia profile pictures, and goth community content 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 gothic portrait generator images.

## Quick start
```bash
node gothicportraitgenerator.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 omactiengartelle/gothic-portrait-generator
```

FILE:README.md
# Gothic Portrait Generator

Generate stunning gothic portraits from text descriptions with dark dramatic lighting, Victorian elegance, and moody atmosphere. Perfect for gothic art, dark fantasy portraits, horror aesthetic avatars, Victorian-style character art, dark academia profile pictures, and goth community content creation.

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

## Install

```bash
npx skills add omactiengartelle/gothic-portrait-generator
```

or

```bash
clawhub install gothic-portrait-generator
```

## Token Setup

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

Pass it via the `--token` flag:

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

## Usage

Generate a gothic portrait with the default prompt:

```bash
node gothicportraitgenerator.js --token YOUR_TOKEN
```

Generate a gothic portrait with a custom description:

```bash
node gothicportraitgenerator.js "pale woman in black lace gown, standing in a dimly lit cathedral, stained glass windows, dramatic shadows" --token YOUR_TOKEN
```

Generate a landscape gothic scene:

```bash
node gothicportraitgenerator.js "abandoned gothic castle at midnight, fog rolling through broken windows, moonlight casting long shadows" --size landscape --token YOUR_TOKEN
```

Use a reference image for style inheritance:

```bash
node gothicportraitgenerator.js "gothic nobleman with raven on shoulder" --ref IMAGE_UUID --token YOUR_TOKEN
```

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 Dimensions

| Size | Width | Height |
|------|-------|--------|
| `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:gothicportraitgenerator.js
#!/usr/bin/env node

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

// Parse CLI arguments
let prompt = null;
let size = 'portrait';
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\u2717 Token required. Pass via: --token YOUR_TOKEN');
  console.error('  Get yours at: https://www.neta.art/open/');
  process.exit(1);
}

if (!prompt) {
  prompt = 'gothic portrait, dramatic dark lighting, ornate Victorian setting, deep shadows, rich dark tones, moody atmosphere, detailed face, elegant gothic fashion, cathedral background, candlelight, oil painting texture';
}

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(`\u2717 Invalid size "size". Use: 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 text = await createRes.text();
    console.error(`\u2717 API error (createRes.status): text`);
    process.exit(1);
  }

  const createData = await createRes.text();
  let taskUuid;
  try {
    const parsed = JSON.parse(createData);
    taskUuid = parsed.task_uuid || parsed;
  } catch {
    taskUuid = createData.replace(/"/g, '').trim();
  }

  if (!taskUuid) {
    console.error('\u2717 No task UUID returned 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(`\u2717 Poll error (pollRes.status)`);
      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 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, null, 2));
      process.exit(1);
    }
  }

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

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

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

---
name: webtoon-character-generator
description: AI webtoon character generator — create manhwa-style portraits, Korean comic characters, and webtoon OCs with clean line art, expressive eyes, and vibrant colors. Perfect for webtoon creators, manhwa fans, comic artists, and anyone wanting a modern anime-adjacent digital illustration style via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Webtoon Character Generator

AI webtoon character generator — create manhwa-style portraits, Korean comic characters, and webtoon OCs with clean line art, expressive eyes, and vibrant colors. Perfect for webtoon creators, manhwa fans, comic artists, and anyone wanting a modern anime-adjacent digital illustration style.

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

## Quick start
```bash
node webtooncharactergenerator.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 omactiengartelle/webtoon-character-generator
```

FILE:README.md
# Webtoon Character Generator

Generate manhwa-style character portraits and webtoon OCs from text descriptions — clean line art, highly expressive large eyes, vibrant saturated colors, and the modern Korean webtoon aesthetic, all powered by AI.

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 omactiengartelle/webtoon-character-generator
```

**Via ClawHub:**
```bash
clawhub install webtoon-character-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 webtooncharactergenerator.js "DESCRIPTION" --token YOUR_TOKEN [options]
```

If no description is provided, a default webtoon portrait prompt is used.

### Examples

```bash
# Female protagonist with silver hair and glowing blue eyes
node webtooncharactergenerator.js "female protagonist, silver hair, glowing blue eyes, school uniform, confident expression, webtoon style" --token "$NETA_TOKEN"

# Dark fantasy warrior character
node webtooncharactergenerator.js "dark fantasy male warrior, scar on cheek, black armor, dramatic lighting, webtoon manhwa style" --token "$NETA_TOKEN"

# Landscape orientation
node webtooncharactergenerator.js "cute magical girl, pastel colors, star wand, webtoon style" --token "$NETA_TOKEN" --size landscape

# Tall portrait for a full-body webtoon panel
node webtooncharactergenerator.js "villain character, purple coat, menacing smile, webtoon style" --token "$NETA_TOKEN" --size tall

# Use a reference image UUID for style inheritance
node webtooncharactergenerator.js "same character, summer outfit" --token "$NETA_TOKEN" --ref abc123-uuid-here
```

### Output

Returns a direct image URL.

---

## Options

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

### Size Dimensions

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

---

## Tips for Better Results

- Describe hair color, eye color, outfit, and expression for detailed characters.
- Include style keywords like `webtoon style`, `manhwa aesthetic`, or `Korean comic style`.
- Add mood or lighting cues: `dramatic lighting`, `soft glow`, `backlit`.
- Use `--size tall` for full-body shots suited to webtoon panel layouts.
- Use `--ref` with a previously generated character's UUID to maintain visual consistency across images.


FILE:package.json
{
  "name": "webtoon-character-generator",
  "version": "1.0.1",
  "type": "module",
  "description": "Webtoon Character Generator — AI-powered webtoon character generator ai",
  "license": "MIT"
}

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

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

const prompt =
  args.find((a) => !a.startsWith("--")) ||
  "webtoon manhwa style character portrait, clean crisp line art, highly expressive large eyes, vibrant saturated colors, smooth cel shading, dynamic pose, modern Korean webtoon aesthetic, white background, full body or bust";

const sizeFlag = args[args.indexOf("--size") + 1] || "portrait";
const tokenFlag = args[args.indexOf("--token") + 1] || null;
const refFlag = args.includes("--ref") ? args[args.indexOf("--ref") + 1] : null;

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: [1024, 1024],
  portrait: [832, 1216],
  landscape: [1216, 832],
  tall: [704, 1408],
};

const [width, height] = SIZES[sizeFlag] || SIZES.portrait;

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: {
        "x-token": TOKEN,
        "x-platform": "nieta-app/web",
        "content-type": "application/json",
      },
    };

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

    req.on("error", reject);
    if (body) req.write(JSON.stringify(body));
    req.end();
  });
}

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

async function main() {
  const 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 (refFlag) {
    body.inherit_params = {
      collection_uuid: refFlag,
      picture_uuid: refFlag,
    };
  }

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

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

  if (!taskUuid || typeof taskUuid !== "string") {
    console.error("✗ Failed to get task UUID:", JSON.stringify(makeRes));
    process.exit(1);
  }

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

    const status = poll.task_status;
    if (status === "PENDING" || status === "MODERATION") continue;

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

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

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

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

---
name: tattoo-design-generator
description: AI tattoo design generator for creating custom tattoo concept art, ink illustrations, and tattoo reference sheets. Generate flash tattoo designs, sleeve ideas, minimalist tattoo art, tribal patterns, and fine line tattoo sketches — perfect for tattoo artists, studios, and anyone planning their next ink via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Tattoo Design Generator

AI tattoo design generator for creating custom tattoo concept art, ink illustrations, and tattoo reference sheets. Generate flash tattoo designs, sleeve ideas, minimalist tattoo art, tribal patterns, and fine line tattoo sketches — perfect for tattoo artists, studios, and anyone planning their next ink.

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

## Quick start
```bash
node tattoodesigngenerator.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 omactiengartelle/tattoo-design-generator
```

FILE:README.md
# Tattoo Design Generator

Generate custom tattoo concept art, ink illustrations, and tattoo reference sheets from text descriptions. Describe your idea — a Japanese koi fish, a geometric mandala, a fine line floral sleeve — and get back a ready-to-use tattoo design image. Perfect for tattoo artists, studios, and anyone planning their next ink.

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 omactiengartelle/tattoo-design-generator
```

**Via ClawHub:**
```bash
clawhub install tattoo-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

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

### Examples

```bash
# Fine line botanical sleeve concept
node tattoodesigngenerator.js "fine line botanical sleeve with roses, ferns, and butterflies, delicate linework, black ink" --token "$NETA_TOKEN"

# Traditional Japanese koi
node tattoodesigngenerator.js "traditional Japanese koi fish tattoo, bold outlines, red and black ink, waves" --token "$NETA_TOKEN" --size square

# Minimalist geometric mandala
node tattoodesigngenerator.js "minimalist geometric mandala tattoo, dotwork shading, sacred geometry, black ink" --token "$NETA_TOKEN" --size portrait

# Tribal armband
node tattoodesigngenerator.js "Polynesian tribal armband tattoo, bold black ink, traditional patterns" --token "$NETA_TOKEN" --size landscape
```

### Output

Returns a direct image URL.

---

## Options

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

### Size dimensions

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

---

## Default Prompt

If no prompt is provided, the script uses:

```
tattoo design concept art, bold black ink linework, intricate detailed illustration, clean lines, black and white tattoo sketch, fine line tattoo style, ready for skin
```


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

FILE:tattoodesigngenerator.js
#!/usr/bin/env node
// Tattoo Design Generator — AI-powered tattoo concept art via Neta API

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

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

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

const TOKEN = tokenFlag;

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

if (!prompt) {
  prompt = 'tattoo design concept art, bold black ink linework, intricate detailed illustration, clean lines, black and white tattoo sketch, fine line tattoo style, ready for skin';
}

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

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

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

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

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

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

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

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

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

  return taskUuid;
}

async function pollTask(taskUuid) {
  const MAX_ATTEMPTS = 90;
  const POLL_INTERVAL_MS = 2000;

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

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

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

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

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

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

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

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

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

(async () => {
  const taskUuid = await makeImage();
  await pollTask(taskUuid);
})();

---
name: caricature-portrait-generator
description: Generate hilarious AI caricature portraits with exaggerated features — turn any description into a funny caricature, cartoon portrait, or comic likeness. Perfect for gifts, social media, party invitations, and personalized art. Supports caricature generator, exaggerated portrait, cartoon face, comic portrait, and funny face art styles via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# AI Caricature Portrait Generator

Generate hilarious AI caricature portraits with exaggerated features — turn any description into a funny caricature, cartoon portrait, or comic likeness. Perfect for gifts, social media, party invitations, and personalized art. Supports caricature generator, exaggerated portrait, cartoon face, comic portrait, and funny face art styles.

## Token

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

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

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

## Quick start
```bash
node caricatureportraitgenerator.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 omactiengartelle/caricature-portrait-generator
```

FILE:README.md
# AI Caricature Portrait Generator

Generate hilarious AI caricature portraits with exaggerated features — describe any person, character, or scenario and get a funny caricature, cartoon portrait, or comic likeness back as a direct image URL. Perfect for gifts, social media avatars, party invitations, and personalized art.

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

## Install

```bash
npx skills add omactiengartelle/caricature-portrait-generator
```

```bash
clawhub install caricature-portrait-generator
```

## Token Setup

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

Pass it via the `--token` flag:

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

## Usage

```bash
# Basic — uses default portrait size
node caricatureportraitgenerator.js "middle-aged professor with wild white hair and oversized glasses, academic caricature style" --token "$NETA_TOKEN"

# Square format
node caricatureportraitgenerator.js "cheerful chef with a giant puffy hat and rosy cheeks, bold comic linework" --token "$NETA_TOKEN" --size square

# Tall format with custom description
node caricatureportraitgenerator.js "rock musician with enormous hair, tiny sunglasses, and a giant guitar" --token "$NETA_TOKEN" --size tall

# With a reference image UUID for style inheritance
node caricatureportraitgenerator.js "friendly librarian with stacked books for a head" --token "$NETA_TOKEN" --ref xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

## Options

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

### Size dimensions

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

## Output

Returns a direct image URL. Save it with `curl` or open it in any browser:

```bash
URL=$(node caricatureportraitgenerator.js "your prompt" --token "$NETA_TOKEN")
curl -o caricature.png "$URL"
```

## Default Prompt

If no prompt argument is given, the script uses:

```
caricature portrait with exaggerated facial features, comically enlarged eyes and expression, bold linework, professional caricature art style, vibrant colors, humorous likeness
```

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

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

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

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

for (let i = 0; i < args.length; i++) {
  if (args[i] === '--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 = 'caricature portrait with exaggerated facial features, comically enlarged eyes and expression, bold linework, professional caricature art style, vibrant colors, humorous likeness';
}

const sizes = {
  square: [1024, 1024],
  portrait: [832, 1216],
  landscape: [1216, 832],
  tall: [704, 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, 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 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 createRes = await request('POST', 'api.talesofai.com', '/v3/make_image', body);

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

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

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

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

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

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

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

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

---
name: book-cover-generator
description: AI book cover generator for indie authors and self-publishers — create stunning KDP book covers, novel cover art, ebook covers, and Kindle cover designs using AI. Generate genre-specific covers for fantasy, romance, thriller, sci-fi, and non-fiction books in portrait format via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Book Cover Generator

AI book cover generator for indie authors and self-publishers — create stunning KDP book covers, novel cover art, ebook covers, and Kindle cover designs using AI. Generate genre-specific covers for fantasy, romance, thriller, sci-fi, and non-fiction books in portrait format.

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

## Quick start
```bash
node bookcovergenerator.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 omactiengartelle/book-cover-generator
```

FILE:README.md
# Book Cover Generator

Generate stunning book covers from text descriptions using AI — perfect for indie authors, self-publishers, and KDP creators. Describe your book's genre, mood, characters, and setting, and receive professional-quality cover art ready for Kindle, ebook, and print-on-demand publishing.

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

## Install

```bash
# Via npx skills
npx skills add omactiengartelle/book-cover-generator

# Via ClawHub
clawhub install book-cover-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 bookcovergenerator.js "<description>" --token YOUR_TOKEN [--size <size>] [--ref <uuid>]
```

### Examples

```bash
# Fantasy novel cover
node bookcovergenerator.js "A lone wizard standing at the edge of a cliff overlooking a dragon-filled valley, epic fantasy, dramatic stormy sky, oil painting style" --token "$NETA_TOKEN"

# Romance novel cover
node bookcovergenerator.js "Two silhouettes embracing on a moonlit beach, soft warm tones, romantic atmosphere, cinematic lighting" --token "$NETA_TOKEN"

# Thriller cover
node bookcovergenerator.js "A shadowy figure in a rain-soaked city alley, neon reflections, dark and suspenseful mood, photorealistic" --token "$NETA_TOKEN"

# Non-fiction business book
node bookcovergenerator.js "Clean minimalist design, bold typography space, ascending graph motif, professional corporate blues and whites" --token "$NETA_TOKEN"

# Landscape size
node bookcovergenerator.js "Sci-fi spaceship battle above a ringed gas giant, cinematic, highly detailed" --token "$NETA_TOKEN" --size landscape

# With style reference
node bookcovergenerator.js "Dark gothic castle on a stormy night" --token "$NETA_TOKEN" --ref abc123-uuid-here
```

## Options

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

### Size Dimensions

| Size | Dimensions | Best For |
|------|-----------|----------|
| `portrait` | 832 × 1216 | Standard book covers, KDP, Kindle |
| `square` | 1024 × 1024 | Social media, thumbnails |
| `landscape` | 1216 × 832 | Wide banners, panoramic scenes |
| `tall` | 704 × 1408 | Phone wallpapers, tall formats |

## Output

Returns a direct image URL. Download or open it in your browser to save the generated cover.

## Tips for Great Book Covers

- **Be specific about genre**: "dark fantasy", "cozy mystery", "literary fiction" help set the tone
- **Describe the mood**: "eerie", "hopeful", "tense", "whimsical"
- **Mention art style**: "oil painting", "watercolor", "photorealistic", "illustrated", "minimalist"
- **Leave room for text**: add "with space for title text at top" or "negative space for typography"
- **Specify lighting**: "golden hour", "dramatic side lighting", "soft diffused light"

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

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

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

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

const TOKEN = tokenFlag;

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

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

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

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

// --- HTTP helpers ---
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: {
        "x-token": TOKEN,
        "x-platform": "nieta-app/web",
        "content-type": "application/json",
      },
    };
    const req = https.request(options, (res) => {
      let data = "";
      res.on("data", (chunk) => (data += chunk));
      res.on("end", () => {
        try {
          resolve(JSON.parse(data));
        } catch {
          resolve(data.trim());
        }
      });
    });
    req.on("error", reject);
    if (body) req.write(JSON.stringify(body));
    req.end();
  });
}

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

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

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

  // Submit job
  const submitRes = await request("POST", "https://api.talesofai.com/v3/make_image", body);

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

  // Poll for result
  const MAX_ATTEMPTS = 90;
  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
    await sleep(2000);

    const pollRes = await request(
      "GET",
      `https://api.talesofai.com/v1/artifact/task/taskUuid`,
      null
    );

    const status = pollRes && pollRes.task_status;

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

    // Done — extract URL
    let imageUrl = null;
    if (pollRes.artifacts && pollRes.artifacts[0] && pollRes.artifacts[0].url) {
      imageUrl = pollRes.artifacts[0].url;
    } else if (pollRes.result_image_url) {
      imageUrl = pollRes.result_image_url;
    }

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

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

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

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

---
name: barbie-style-generator
description: any description into a stunning Barbie-style AI portrait with hyper-feminine glamour doll aesthetics. Generate pastel-saturated fashion doll images, pink editorial portraits, and Barbie movie-inspired looks — perfect for Instagram Reels, TikTok content, identity play, and branded visuals via the Neta AI image generation API (free trial at neta.art/open).
tools: Bash
---

# Barbie Style Generator

any description into a stunning Barbie-style AI portrait with hyper-feminine glamour doll aesthetics. Generate pastel-saturated fashion doll images, pink editorial portraits, and Barbie movie-inspired looks — perfect for Instagram Reels, TikTok content, identity play, and branded visuals.

## Token

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

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

## When to use
Use when someone asks to generate or create barbie style ai photo generator images.

## Quick start
```bash
node barbiestylegenerator.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 omactiengartelle/barbie-style-generator
```

FILE:README.md
# Barbie Style Generator

Generate stunning Barbie-style AI portraits from text descriptions — hyper-feminine glamour doll aesthetics, pastel-saturated pink editorial looks, and Barbie movie-inspired visuals. Describe a scene, a mood, or a character, and get back a high-quality fashion doll portrait perfect for Instagram Reels, TikTok content, identity play, and branded visuals.

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 omactiengartelle/barbie-style-generator
```

**Via ClawHub:**
```bash
clawhub install barbie-style-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 barbiestylegenerator.js "<description>" --token YOUR_TOKEN [--size <size>] [--ref <picture_uuid>]
```

### Examples

```bash
# Default Barbie glamour portrait
node barbiestylegenerator.js "hyper-feminine Barbie doll aesthetic portrait, pastel pink fashion editorial" --token "$NETA_TOKEN"

# Dreamhouse Barbie in a pink convertible
node barbiestylegenerator.js "Barbie driving a pink convertible, Malibu beach, sunny day, fashion doll style" --token "$NETA_TOKEN"

# Landscape format
node barbiestylegenerator.js "Barbie at a runway fashion show, glitter and sequins" --token "$NETA_TOKEN" --size landscape

# Tall format for Stories/Reels
node barbiestylegenerator.js "space Barbie, cosmic glam, star-studded outfit, pink galaxy backdrop" --token "$NETA_TOKEN" --size tall

# With style reference UUID
node barbiestylegenerator.js "Barbie at the Oscars, red carpet glamour" --token "$NETA_TOKEN" --ref abc123-uuid
```

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

---

## Options

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

### Size dimensions

| Size | Width | Height | Best for |
|------|-------|--------|----------|
| `portrait` | 832 | 1216 | Standard portrait, Instagram posts |
| `landscape` | 1216 | 832 | Wide shots, banners |
| `square` | 1024 | 1024 | Instagram grid, profile images |
| `tall` | 704 | 1408 | Stories, TikTok, Reels |

---

## How it works

1. Sends your text description to the Neta image generation API
2. Polls for task completion (up to 3 minutes)
3. Prints the final image URL to stdout when ready

Progress messages are written to stderr so the URL on stdout can be cleanly piped or captured:

```bash
IMAGE_URL=$(node barbiestylegenerator.js "pink Barbie dreamhouse" --token "$NETA_TOKEN")
echo "Generated: $IMAGE_URL"
```


FILE:barbiestylegenerator.js
#!/usr/bin/env node
import { parseArgs } from "node:util";

const { values, positionals } = parseArgs({
  args: process.argv.slice(2),
  options: {
    token: { type: "string" },
    size: { type: "string", default: "portrait" },
    ref: { type: "string" },
  },
  allowPositionals: true,
});

const PROMPT =
  positionals[0] ||
  "hyper-feminine Barbie doll aesthetic portrait, pastel-saturated pink and blonde fashion editorial look, flawless glamorous makeup, dreamy soft studio lighting, luxury fashion backdrop, ultra-stylized plastic doll beauty, perfect skin, big sparkling eyes";

const TOKEN = values.token;

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 size = SIZES[values.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: size.width,
  height: size.height,
  meta: { entrance: "PICTURE,VERSE" },
  context_model_series: "8_image_edit",
};

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

console.error("Generating Barbie-style image...");

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

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

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

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

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

const MAX_ATTEMPTS = 90;
const POLL_INTERVAL_MS = 2000;

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

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

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

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

  if (status === "PENDING" || status === "MODERATION") {
    console.error(`Poll i + 1: status...`);
    continue;
  }

  // Done
  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("✗ Timed out waiting for image generation.");
process.exit(1);

FILE:package.json
{"name":"barbie-style-generator","version":"1.0.0","type":"module","description":"Barbie Style Generator — AI-powered barbie style ai photo generator","license":"MIT"}