@talesofai/neta-skills 0.6.0

package/bin/apis/collection.js

@@ -0,0 +1,87 @@
+import qs from "qs";
+export const isVerseCTA = (cta_info) => {
+    return "interactive_config" in cta_info;
+};
+export const createCollectionApis = (client) => {
+    const createCollection = async () => {
+        return client
+            .get("/v1/story/new-story")
+            .then((res) => res.data.data.uuid);
+    };
+    const saveCollection = async (payload) => {
+        return await client
+            .put("/v3/story/story", payload)
+            .then((res) => res.data);
+    };
+    const publishCollection = async (uuid, options) => {
+        const { triggerTCPCommentNow, triggerSameStyleReply, sync_mode } = options ?? {};
+        return client
+            .put(`/v1/story/story-publish?${qs.stringify({
+            storyId: uuid,
+            triggerTCPCommentNow: triggerTCPCommentNow ?? false,
+            triggerSameStyleReply: triggerSameStyleReply ?? false,
+            sync_mode: sync_mode ?? false,
+        })}`)
+            .then((res) => res.data.status === "SUCCESS");
+    };
+    const collectionDetails = async (uuids) => {
+        return client
+            .get("/v3/story/story-detail", {
+            params: {
+                uuids: uuids.join(","),
+            },
+        })
+            .then((res) => res.data);
+    };
+    const likeCollection = async (storyId, options) => {
+        const { is_cancel } = options ?? {};
+        const response = await client.request({
+            method: "PUT",
+            url: "/v1/story/story-like",
+            data: {
+                storyId,
+                is_cancel: is_cancel ?? false,
+            },
+        });
+        return response.status === 200 || response.status === 204;
+    };
+    const createComment = async (params) => {
+        const response = await client.request({
+            method: "POST",
+            url: "/v1/comment/comment",
+            data: {
+                content: params.content,
+                parent_uuid: params.parent_uuid,
+                parent_type: params.parent_type,
+                at_users: params.at_users ?? [],
+            },
+        });
+        return {
+            success: response.status === 200 || response.status === 201,
+            comment: response.data,
+        };
+    };
+    const favorCollection = async (storyId, options) => {
+        const { is_cancel } = options ?? {};
+        const response = await client.request({
+            method: "PUT",
+            url: "/v1/story/story-favor",
+            data: {
+                storyId,
+                is_cancel: is_cancel ?? false,
+            },
+        });
+        return {
+            success: response.status === 200 || response.status === 204,
+        };
+    };
+    return {
+        createCollection,
+        saveCollection,
+        publishCollection,
+        collectionDetails,
+        likeCollection,
+        createComment,
+        favorCollection,
+    };
+};

package/bin/apis/config.js

@@ -0,0 +1,49 @@
+import { safeParseJson } from "../utils/json.js";
+export function createConfigApis(client) {
+    const getConfig = async (namespace, key) => {
+        const res = await client
+            .get(`/v1/configs/config`, {
+            params: {
+                namespace,
+                key,
+            },
+        })
+            .then((res) => res.data);
+        if (!res)
+            return null;
+        switch (res.type) {
+            case "string": {
+                const value = String(res.value);
+                if (value === "null") {
+                    return null;
+                }
+                else {
+                    return value;
+                }
+            }
+            case "int": {
+                const value = Number(res.value);
+                if (Number.isNaN(value)) {
+                    return null;
+                }
+                else {
+                    return value;
+                }
+            }
+            case "json": {
+                const value = safeParseJson(res.value);
+                if (value === null) {
+                    return null;
+                }
+                else {
+                    return value;
+                }
+            }
+            default:
+                return null;
+        }
+    };
+    return {
+        getConfig,
+    };
+}

package/bin/apis/feeds.js

@@ -0,0 +1,34 @@
+export const createFeedsApis = (client) => {
+    const homeList = (params) => {
+        return client.get("/v1/home/feed/mainlist", {
+            params,
+        });
+    };
+    const interactiveItem = async (params) => {
+        return client
+            .get("/v1/home/feed/interactive", {
+            params: {
+                collection_uuid: params.collection_uuid,
+                page_index: 0,
+                page_size: 1,
+            },
+        })
+            .then((res) => res.data.module_list[0]);
+    };
+    const interactiveList = async (params) => {
+        return client
+            .get("/v1/recsys/feed/interactive", {
+            params,
+        })
+            .then((res) => res.data);
+    };
+    const tags = (uuid) => client
+        .get(`/v1/home/collection/${uuid}/tags`)
+        .then((res) => res.data);
+    return {
+        homeList,
+        interactiveList,
+        interactiveItem,
+        tags,
+    };
+};

package/bin/apis/gpt.js

@@ -0,0 +1,10 @@
+export const createGptApis = (client) => {
+    const messages = async (uuid) => {
+        return client
+            .get(`/v3/gpt/message/${uuid}`)
+            .then((res) => res.data);
+    };
+    return {
+        messages,
+    };
+};

package/bin/apis/hashtag.js

@@ -0,0 +1,23 @@
+export const createHashtagApis = (client) => {
+    const createHashtag = (name, fromHashtag) => client
+        .post("/v1/hashtag/", { name, base_hashtag: fromHashtag })
+        .then((res) => res.data);
+    const fetchHashtag = async (hashtag, config) => {
+        const url = `/v1/hashtag/hashtag_info/${encodeURIComponent(hashtag)}`;
+        return client.get(url, config).then((res) => res.data);
+    };
+    const fetchCharactersByHashtag = async (hashtag, params, config) => {
+        const url = `/v1/hashtag/${encodeURIComponent(hashtag)}/tcp-list`;
+        return client
+            .get(url, {
+            ...config,
+            params,
+        })
+            .then((res) => res.data);
+    };
+    return {
+        createHashtag,
+        fetchHashtag,
+        fetchCharactersByHashtag,
+    };
+};

package/bin/apis/index.js

@@ -0,0 +1,62 @@
+import axios from "axios";
+import { handleAxiosError } from "../utils/errors.js";
+import { createActivityApis } from "./activity.js";
+import { createArtifactApis } from "./artifact.js";
+import { createAudioApis } from "./audio.js";
+import { createCollectionApis } from "./collection.js";
+import { createConfigApis } from "./config.js";
+import { createFeedsApis } from "./feeds.js";
+import { createGptApis } from "./gpt.js";
+import { createHashtagApis, } from "./hashtag.js";
+import { createPromptApis } from "./prompt.js";
+import { createRecsysApis } from "./recsys.js";
+import { createSpaceApis } from "./space.js";
+import { createTaskApis } from "./task.js";
+import { createTcpApis } from "./tcp.js";
+import { createUserApis } from "./user.js";
+import { createVerseApis } from "./verse.js";
+export const createApis = (option) => {
+    const baseUrl = option.baseUrl;
+    const client = axios.create({
+        adapter: "fetch",
+        baseURL: baseUrl,
+        headers: {
+            ...option.headers,
+        },
+    });
+    client.interceptors.response.use((response) => response, (error) => {
+        handleAxiosError(error);
+    });
+    const tcp = createTcpApis(client);
+    const artifact = createArtifactApis(client);
+    const prompt = createPromptApis(client, tcp, artifact);
+    const gpt = createGptApis(client);
+    const audio = createAudioApis(client);
+    const hashtag = createHashtagApis(client);
+    const activity = createActivityApis(client);
+    const verse = createVerseApis(client);
+    const task = createTaskApis(client);
+    const config = createConfigApis(client);
+    const user = createUserApis(client);
+    const collection = createCollectionApis(client);
+    const feeds = createFeedsApis(client);
+    const space = createSpaceApis(client);
+    const recsys = createRecsysApis(client);
+    return {
+        tcp,
+        prompt,
+        artifact,
+        gpt,
+        audio,
+        hashtag,
+        activity,
+        verse,
+        task,
+        config,
+        user,
+        collection,
+        feeds,
+        space,
+        recsys,
+    };
+};

package/bin/apis/prompt.js

@@ -0,0 +1,120 @@
+import { mapTCP2Tag, REF_IMG_PROMPT_PLACEHOLDER, stringToPrompts, } from "../utils/prompts.js";
+const PRESET_DOMAIN_IMG_REF = "APP/单图/图生图";
+export const createPromptApis = (client, tcpApis, artifactApis) => {
+    const parseVtokens = async (prompt, options) => {
+        const insPrompts = stringToPrompts(prompt, options);
+        const refImages = insPrompts.filter((p) => p.type === "ref_image");
+        const artifacts = await artifactApis
+            .artifactDetail(refImages.map((p) => p.ref_img_uuid ?? ""))
+            .catch(() => []);
+        artifacts.forEach((artifact) => {
+            if (!artifact)
+                return;
+            if (artifact.status !== "SUCCESS")
+                return;
+            if (artifact.modality !== "PICTURE")
+                return;
+            if (!artifact.url)
+                return;
+            const refImage = refImages.find((p) => p.ref_img_uuid === artifact.uuid);
+            if (!refImage)
+                return;
+            refImage.value = artifact.url;
+        });
+        const imgModes = refImages.length > 0 ? await img2imgModes() : [];
+        const resPrompts = await Promise.all(insPrompts.map(async (p) => {
+            if (p.type === "text") {
+                return {
+                    type: "freetext",
+                    weight: p.weight,
+                    value: p.value,
+                };
+            }
+            if (p.type === "ref_image") {
+                if (p.value === REF_IMG_PROMPT_PLACEHOLDER)
+                    return null;
+                if (!p.ref_img_uuid)
+                    return null;
+                if (!p.value)
+                    return null;
+                const imgMode = imgModes.find((m) => m.name === p.name) ?? imgModes[0];
+                if (!imgMode)
+                    return null;
+                return {
+                    uuid: imgMode.uuid,
+                    name: imgMode.name,
+                    type: "ref_image",
+                    weight: p.weight,
+                    value: p.value,
+                    sub_type: p.sub_type,
+                    ref_img_uuid: p.ref_img_uuid,
+                    extra_value: imgMode.extra_value,
+                };
+            }
+            if (p.type !== "character" && p.type !== "elementum")
+                return null;
+            if (p.type === "character") {
+                const characterInAssigns = options?.characters?.find((c) => c.name === p.name);
+                if (characterInAssigns) {
+                    return mapTCP2Tag({
+                        type: "oc",
+                        uuid: characterInAssigns.uuid,
+                        name: characterInAssigns.name,
+                    }, p.weight);
+                }
+            }
+            if (p.type === "elementum") {
+                const elementumInAssigns = options?.elementums?.find((s) => s.name === p.name);
+                if (elementumInAssigns) {
+                    return mapTCP2Tag({
+                        type: "elementum",
+                        uuid: elementumInAssigns.uuid,
+                        name: elementumInAssigns.name,
+                    }, p.weight);
+                }
+            }
+            const res = await tcpApis.searchTCPs({
+                keywords: p.name,
+                page_index: 0,
+                page_size: 1,
+                parent_type: p.type === "character" ? "oc" : "elementum",
+                sort_scheme: "exact",
+            });
+            const first = (() => {
+                if (!res)
+                    return null;
+                if ("list" in res) {
+                    if (p.type === "character") {
+                        return res.list.find((r) => r.type === "oc") ?? null;
+                    }
+                    if (p.type === "elementum") {
+                        return res.list.find((r) => r.type === "elementum") ?? null;
+                    }
+                    return null;
+                }
+                return res;
+            })();
+            if (first) {
+                return mapTCP2Tag(first, p.weight);
+            }
+            return {
+                type: "freetext",
+                weight: p.weight,
+                value: p.name,
+            };
+        }));
+        return resPrompts.filter((r) => r !== null);
+    };
+    const img2imgModes = async () => {
+        return client
+            .get("/v1/prompt/full-prompt-tags", {
+            params: { domain_name: PRESET_DOMAIN_IMG_REF },
+        })
+            .then((res) => res.data.tags)
+            .catch(() => []);
+    };
+    return {
+        img2imgModes,
+        parseVtokens,
+    };
+};

package/bin/apis/recsys.js

@@ -0,0 +1,29 @@
+export const createRecsysApis = (client) => {
+    const suggestKeywords = async (params) => {
+        const response = await client.get("/v1/recsys/autocomplete", { params });
+        return response.data;
+    };
+    const suggestTags = async (params) => {
+        const response = await client.get("/v1/recsys/tags", { params });
+        return response.data;
+    };
+    const suggestCategories = async (params) => {
+        const response = await client.get("/v1/recsys/categories", { params });
+        return response.data;
+    };
+    const suggestContent = async (params) => {
+        const response = await client.post("/v1/recsys/content", params);
+        return response.data;
+    };
+    const validateTaxPath = async (params) => {
+        const response = await client.post("/v1/recsys/validate-tax-path", params);
+        return response.data;
+    };
+    return {
+        suggestKeywords,
+        suggestTags,
+        suggestCategories,
+        suggestContent,
+        validateTaxPath,
+    };
+};

package/bin/apis/space.js

@@ -0,0 +1,48 @@
+import { safeParseJson } from "../utils/json.js";
+export const createSpaceApis = (client) => {
+    const basic = async (hashtag_name) => {
+        const res = await client.get("/v1/space/get-by-hashtag", {
+            params: {
+                hashtag_name,
+            },
+        });
+        return res.data;
+    };
+    const topics = async (space_uuid) => {
+        const res = await client.get("/v1/space/topics", {
+            params: {
+                space_uuid,
+            },
+        });
+        return res.data;
+    };
+    const feeds = async (params) => {
+        return await client
+            .get("/v1/space/collection/feed", {
+            params,
+        })
+            .then((res) => res.data)
+            .then((res) => res.collection_feed_item.map((item) => ({
+            uuid: item.uuid,
+            title: item.title,
+            same_style_count: item.same_style_count,
+            cover_url: item.cover_url,
+            next_view_url: item.next_view_url,
+        })));
+    };
+    const spaceConfigs = async () => {
+        const res = await client.get("/v1/configs/config?namespace=space&key=topic_tags_config");
+        return safeParseJson(res.data.value) ?? {};
+    };
+    const spaceHashtags = async () => {
+        const res = await client.get("/v1/configs/config?namespace=space&key=new_version_hashtag");
+        return safeParseJson(res.data.value) ?? [];
+    };
+    return {
+        basic,
+        topics,
+        feeds,
+        spaceHashtags,
+        spaceConfigs,
+    };
+};

package/bin/apis/task.js

@@ -0,0 +1,21 @@
+export const createTaskApis = (client) => {
+    const rawTask = async (uuid, config) => {
+        return client
+            .get("/v3/task", {
+            params: {
+                taskId: uuid,
+            },
+            ...config,
+        })
+            .then((res) => res.data);
+    };
+    const poolSize = async () => {
+        return client
+            .get("/v3/task-pool")
+            .then((res) => res.data);
+    };
+    return {
+        rawTask,
+        poolSize,
+    };
+};

package/bin/apis/tcp.js

@@ -0,0 +1,16 @@
+export const createTcpApis = (client) => {
+    const searchTCPs = async (query) => {
+        return client
+            .get("/v2/travel/parent-search", { params: query })
+            .then((res) => res.data);
+    };
+    const tcpProfile = async (uuid) => {
+        return client
+            .get(`/v2/travel/parent/${uuid}/profile`)
+            .then((res) => res.data);
+    };
+    return {
+        searchTCPs,
+        tcpProfile,
+    };
+};

package/bin/apis/types.js

@@ -0,0 +1,76 @@
+export const IMAGE_GENERATE_ASPECTS = [
+    {
+        aspect: "1:1",
+        size: [512, 512],
+        resultSize: [1024, 1024],
+    },
+    {
+        aspect: "3:4",
+        size: [576, 768],
+        resultSize: [896, 1152],
+    },
+    {
+        aspect: "4:3",
+        size: [768, 576],
+        resultSize: [1152, 896],
+    },
+    {
+        aspect: "9:16",
+        size: [576, 1024],
+        resultSize: [768, 1344],
+    },
+    {
+        aspect: "16:9",
+        size: [1024, 576],
+        resultSize: [1344, 768],
+    },
+];
+export const buildMakeImagePayload = (vtokens, options, inherit) => {
+    const { make_image_aspect, advanced_translator, negative_freetext, context_model_series, entrance_uuid, manuscript_uuid, assign_key, toolcall_uuid, } = options;
+    const imageAspect = IMAGE_GENERATE_ASPECTS.find((a) => a.aspect === make_image_aspect)?.size ?? [576, 768];
+    return {
+        storyId: "DO_NOT_USE",
+        jobType: "universal",
+        rawPrompt: vtokens,
+        width: imageAspect[0],
+        height: imageAspect[1],
+        meta: {
+            entrance: "PICTURE,VERSE",
+            entrance_uuid,
+            manuscript_uuid,
+            assign_key,
+            toolcall_uuid,
+        },
+        inherit_params: inherit,
+        advanced_translator,
+        context_model_series,
+        negative_freetext: negative_freetext,
+    };
+};
+export const buildMakeVideoPayload = (image_url, work_flow_text, work_flow_model, options) => {
+    const { entrance_uuid, manuscript_uuid, inherit_params, assign_key, toolcall_uuid, } = options || {};
+    return {
+        rawPrompt: [],
+        image_url,
+        work_flow_text,
+        work_flow_model,
+        inherit_params,
+        meta: {
+            entrance: "VIDEO,VERSE",
+            entrance_uuid,
+            manuscript_uuid,
+            assign_key,
+            toolcall_uuid,
+        },
+    };
+};
+export const isTextAssign = (assign) => typeof assign === "string";
+export const isCharacterAssign = (assign) => typeof assign === "object" && assign !== null && assign.type === "character";
+export const isElementumAssign = (assign) => typeof assign === "object" && assign !== null && assign.type === "elementum";
+export const isImageAssign = (assign) => typeof assign === "object" && assign !== null && assign.type === "image";
+export const isVideoAssign = (assign) => typeof assign === "object" && assign !== null && assign.type === "video";
+export const isAudioAssign = (assign) => typeof assign === "object" && assign !== null && assign.type === "audio";
+export const isHtmlTemplateAssign = (assign) => typeof assign === "object" &&
+    assign !== null &&
+    assign.type === "html_template";
+export const isEmptyAssign = (assign) => assign === null;

package/bin/apis/user.js

@@ -0,0 +1,45 @@
+export const createUserApis = (client) => {
+    return {
+        me: async () => {
+            const res = await client.get("/v1/user/");
+            return res.data ?? null;
+        },
+        subscribeUser: async (params) => {
+            const response = await client.request({
+                method: "PUT",
+                url: "/v1/user/user-subscribe",
+                data: {
+                    user_uuid: params.user_uuid,
+                    is_cancel: params.is_cancel ?? false,
+                },
+            });
+            return {
+                success: response.status === 200 || response.status === 204,
+                subscribe_status: response.data
+                    ?.subscribe_status,
+            };
+        },
+        getSubscribeList: async (params) => {
+            const response = await client.request({
+                method: "GET",
+                url: "/v1/user/subscribe-list",
+                params: {
+                    page_index: params?.page_index ?? 0,
+                    page_size: params?.page_size ?? 20,
+                },
+            });
+            return response.data;
+        },
+        getFanList: async (params) => {
+            const response = await client.request({
+                method: "GET",
+                url: "/v1/user/fan-list",
+                params: {
+                    page_index: params?.page_index ?? 0,
+                    page_size: params?.page_size ?? 20,
+                },
+            });
+            return response.data;
+        },
+    };
+};

package/bin/apis/verse.js

@@ -0,0 +1,18 @@
+export const createVerseApis = (client) => {
+    const patchHtml = async (params) => {
+        return client
+            .post("/v1/verse/modifyhtml", params, {
+            timeout: 20 * 1000,
+        })
+            .then((res) => res.data);
+    };
+    const versePreset = async (uuid) => client.get(`/v1/verse/preset/${uuid}`).then((res) => res.data);
+    const drawRedpacket = async (params) => client
+        .post("/v1/redpacket/draw", params)
+        .then((res) => res.data);
+    return {
+        patchHtml,
+        versePreset,
+        drawRedpacket,
+    };
+};

package/bin/cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { program } from "@commander-js/extra-typings";
+import dotenv from "dotenv-flow";
+import pkg from "../package.json" with { type: "json" };
+import { buildCommands } from "./commands/load.js";
+// Load environment variables
+dotenv.config();
+program
+    .name("neta")
+    .description("NETA CLI - Neta API Client")
+    .version(pkg.version);
+const cli = program
+    .option("--token <string>", "neta token (default: from env NETA_TOKEN)")
+    .option("--api_base_url <string>", "api base url (default: NETA_API_BASE_URL or locale-based default)");
+await buildCommands(cli);
+cli.parse(process.argv);

package/bin/commands/community/create_comment.cmd.en_us.yml

@@ -0,0 +1,4 @@
+name: create_comment
+title: Comment on Collection, Character, or Elementum
+description: Create a comment on a collection, character, or elementum.
+