yuanflow-cli 0.1.0

package/src/ycloud/commands/kb.js

@@ -0,0 +1,82 @@
+import { apiPost } from "../core/http.js";
+import { getToken } from "../core/token.js";
+import {
+  getGlobalFlagsHelp,
+  parseFloatNumber,
+  parseInteger,
+} from "./shared.js";
+
+export function getKbHelp() {
+  return `Search knowledge base content
+
+Usage:
+  ycloud kb search [flags]
+
+Required Flags:
+  --query string         search keyword
+
+Optional Flags:
+  --top-k int            number of results to return (default 5)
+  --min-score float      minimum similarity score
+  --course-name string   course name filter
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud kb search --query "短视频脚本结构" --top-k 5 --output json
+
+Read on success:
+  data.hits
+
+Read on error:
+  error.code
+  error.message
+  error.retryable`;
+}
+
+async function requireToken(context) {
+  const token = await getToken();
+  if (!token) {
+    return context.fail(
+      context.commandName,
+      "TOKEN_MISSING",
+      "缺少 YUANCHUANG_API_TOKEN",
+      3,
+      false,
+    );
+  }
+  return token;
+}
+
+export async function executeKbSearch(context, tokens) {
+  const options = context.parseCommandFlags(tokens);
+  if (!options.query) {
+    return context.fail(
+      "kb search",
+      "BAD_ARGUMENT",
+      "缺少必填参数 --query",
+      2,
+      false,
+    );
+  }
+
+  const token = await requireToken(context);
+  if (typeof token !== "string") {
+    return token;
+  }
+
+  const data = await apiPost("/v1/knowledge-base/search", {
+    token,
+    traceId: context.globalOptions.traceId,
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+    body: {
+      query: options.query,
+      top_k: parseInteger(options["top-k"]) ?? 5,
+      min_score: parseFloatNumber(options["min-score"]),
+      course_name: options["course-name"],
+    },
+  });
+
+  return context.ok("kb search", data);
+}

package/src/ycloud/commands/schema.js

@@ -0,0 +1,229 @@
+import { fetchOpenApiSpec } from "../core/http.js";
+import { getGlobalFlagsHelp } from "./shared.js";
+
+const COMMAND_SCHEMA_MAP = {
+  "auth.validate": {
+    command: "auth validate",
+    method: "GET",
+    path: "/v1/auth/validate",
+    cliFlags: [],
+  },
+  "auth.info": {
+    command: "auth info",
+    method: "GET",
+    path: "/v1/auth/info",
+    cliFlags: [],
+  },
+  "auth.charges": {
+    command: "auth charges",
+    method: "GET",
+    path: "/v1/auth/charges",
+    cliFlags: [
+      { flag: "--model-id", apiField: "model_id", required: false },
+      { flag: "--charge-type", apiField: "charge_type", required: false },
+      { flag: "--user-level", apiField: "user_level", required: false },
+      { flag: "--start-at", apiField: "start_at", required: false },
+      { flag: "--end-at", apiField: "end_at", required: false },
+      { flag: "--limit", apiField: "limit", required: false },
+      { flag: "--offset", apiField: "offset", required: false },
+    ],
+  },
+  "health.check": {
+    command: "health check",
+    method: "GET",
+    path: "/v1/health",
+    cliFlags: [],
+  },
+  "tool.catalog": {
+    command: "tool catalog",
+    method: "GET",
+    path: "/v1/tools/catalog",
+    cliFlags: [],
+  },
+  "version.check": {
+    command: "version check",
+    method: "GET",
+    path: "/v1/version/check",
+    cliFlags: [
+      { flag: "--app-id", apiField: "app_id", required: false },
+      { flag: "--platform", apiField: "platform", required: false },
+      { flag: "--channel", apiField: "channel", required: false },
+      {
+        flag: "--current-version",
+        apiField: "current_version",
+        required: false,
+      },
+      { flag: "--current-build", apiField: "current_build", required: false },
+    ],
+  },
+  "tool.execute": {
+    command: "tool execute",
+    method: "POST",
+    path: "/v1/tools/execute",
+    cliFlags: [
+      { flag: "--tool-id", apiField: "tool_id", required: true },
+      { flag: "--params", apiField: "params", required: false },
+      { flag: "--params-file", apiField: "params", required: false },
+      { flag: "--session-id", apiField: "session_id", required: false },
+      { flag: "--trace-id", apiField: "trace_id", required: false },
+      {
+        flag: "--idempotency-key",
+        apiField: "idempotency_key",
+        required: false,
+      },
+    ],
+  },
+  "kb.search": {
+    command: "kb search",
+    method: "POST",
+    path: "/v1/knowledge-base/search",
+    cliFlags: [
+      { flag: "--query", apiField: "query", required: true },
+      { flag: "--top-k", apiField: "top_k", required: false },
+      { flag: "--min-score", apiField: "min_score", required: false },
+      { flag: "--course-name", apiField: "course_name", required: false },
+    ],
+  },
+  "analysis.creator-profile": {
+    command: "analysis creator-profile",
+    method: "POST",
+    path: "/v1/analysis/douyin/creator-profile",
+    cliFlags: [
+      { flag: "--profile-url", apiField: "profile_url", required: true },
+      { flag: "--video-limit", apiField: "video_limit", required: false },
+    ],
+  },
+  "compliance.check": {
+    command: "compliance check",
+    method: "POST",
+    path: "/v1/compliance/check",
+    cliFlags: [
+      { flag: "--content", apiField: "content", required: false },
+      { flag: "--content-file", apiField: "content", required: false },
+      { flag: "--project-id", apiField: "project_id", required: false },
+      { flag: "--metadata", apiField: "metadata", required: false },
+      { flag: "--metadata-file", apiField: "metadata", required: false },
+    ],
+  },
+};
+
+export function getSchemaHelp() {
+  return `Inspect command parameter schema from OpenAPI
+
+Usage:
+  ycloud schema <command> [flags]
+
+Required Flags:
+  none
+
+Optional Flags:
+  none
+
+${getGlobalFlagsHelp()}
+
+Examples:
+  ycloud schema list --output json
+  ycloud schema kb.search --output json
+  ycloud schema tool.execute --output text
+
+Read on success:
+  data.command
+  data.api.path
+  data.api.request_body
+
+Read on error:
+  error.code
+  error.message
+  error.retryable`;
+}
+
+function dereferenceSchema(spec, schema) {
+  if (!schema) {
+    return {};
+  }
+  if (schema.$ref) {
+    const refName = schema.$ref.split("/").pop();
+    return spec.components?.schemas?.[refName] || {};
+  }
+  return schema;
+}
+
+function normalizeProperties(properties = {}) {
+  return Object.entries(properties).map(([name, value]) => ({
+    name,
+    type: value.type || value.$ref || "unknown",
+  }));
+}
+
+export async function executeSchema(context, tokens) {
+  const key = tokens[0];
+  if (!key) {
+    return context.fail(
+      "schema",
+      "BAD_ARGUMENT",
+      "缺少命令标识，例如 kb.search",
+      2,
+      false,
+    );
+  }
+
+  if (key === "list") {
+    return context.ok("schema list", {
+      commands: Object.entries(COMMAND_SCHEMA_MAP).map(([itemKey, value]) => ({
+        key: itemKey,
+        command: value.command,
+        method: value.method,
+        path: value.path,
+      })),
+    });
+  }
+
+  const target = COMMAND_SCHEMA_MAP[key];
+  if (!target) {
+    return context.fail(
+      "schema",
+      "BAD_ARGUMENT",
+      `不支持的 schema 命令: ${key}`,
+      2,
+      false,
+    );
+  }
+
+  const spec = await fetchOpenApiSpec({
+    timeout: context.globalOptions.timeout,
+    baseUrl: context.globalOptions.baseUrl,
+  });
+  const operation =
+    spec.paths?.[target.path]?.[target.method.toLowerCase()] || {};
+
+  let requestBody = {
+    required: [],
+    properties: [],
+  };
+
+  const bodySchema = dereferenceSchema(
+    spec,
+    operation.requestBody?.content?.["application/json"]?.schema,
+  );
+  if (bodySchema && Object.keys(bodySchema).length > 0) {
+    requestBody = {
+      required: bodySchema.required || [],
+      properties: normalizeProperties(bodySchema.properties),
+    };
+  }
+
+  const data = {
+    command: target.command,
+    cli: {
+      flags: target.cliFlags,
+    },
+    api: {
+      method: target.method,
+      path: target.path,
+      summary: operation.summary || null,
+      request_body: requestBody,
+    },
+  };
+
+  return context.ok(`schema ${key}`, data);
+}

package/src/ycloud/commands/shared.js

@@ -0,0 +1,30 @@
+export function getGlobalFlagsHelp() {
+  return `Global Flags:
+  --output string        output format: json (default) | text
+  --trace-id string      optional request trace id
+  --timeout int          request timeout in milliseconds
+  --base-url string      override API base URL`;
+}
+
+export function parseInteger(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+
+export function parseFloatNumber(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  const parsed = Number.parseFloat(String(value));
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+
+export function parseJsonString(value) {
+  if (!value) {
+    return undefined;
+  }
+  return JSON.parse(value);
+}

package/src/ycloud/commands/tool-registry.js

@@ -0,0 +1,209 @@
+const STATIC_TOOL_REGISTRY = {
+  content: {
+    title: "content creation tools",
+    commands: {
+      "knowledge-base-search": {
+        toolId: "knowledge_base_search",
+        commandName: "content knowledge-base-search",
+        description: "Search knowledge base content via wrapped tool",
+        requiredFlags: ["query"],
+      },
+      "copywriting-generate": {
+        toolId: "copywriting_generate",
+        commandName: "content copywriting-generate",
+        description: "Generate short video copywriting",
+        requiredFlags: ["task"],
+      },
+      "douyin-topic-generate": {
+        toolId: "douyin_topic_generate",
+        commandName: "content douyin-topic-generate",
+        description: "Generate Douyin topic ideas",
+        requiredFlags: ["prompt"],
+      },
+      "doubao-image-generate": {
+        toolId: "doubao_image_generate",
+        commandName: "content doubao-image-generate",
+        description: "Generate image assets with Doubao image model",
+        requiredFlags: ["prompt"],
+      },
+      "script-generate": {
+        toolId: "script_generate",
+        commandName: "content script-generate",
+        description: "Generate video script content",
+        requiredFlags: ["task", "duration-seconds"],
+      },
+      "xiaohongshu-content-generate": {
+        toolId: "xiaohongshu_content_generate",
+        commandName: "content xiaohongshu-content-generate",
+        description: "Generate Xiaohongshu content and images",
+        requiredFlags: ["prompt"],
+      },
+    },
+  },
+  oss: {
+    title: "oss tools",
+    commands: {
+      "temp-policy": {
+        toolId: "oss_temp_policy_get",
+        commandName: "oss temp-policy",
+        description: "Get OSS temporary object policy",
+        requiredFlags: [],
+      },
+      "upload-base64": {
+        toolId: "oss_upload_base64",
+        commandName: "oss upload-base64",
+        description: "Upload Base64 payload to OSS",
+        requiredFlags: ["filename", "content-base64"],
+      },
+    },
+  },
+  speech: {
+    title: "speech tools",
+    commands: {
+      recognition: {
+        toolId: "speech_recognition",
+        commandName: "speech recognition",
+        description: "Recognize speech from audio file",
+        requiredFlags: ["audio-url"],
+      },
+      synthesis: {
+        toolId: "speech_synthesis",
+        commandName: "speech synthesis",
+        description: "Synthesize speech audio from text",
+        requiredFlags: ["text"],
+      },
+      "disfluency-trim-plan": {
+        toolId: "speech_disfluency_trim_plan",
+        commandName: "speech disfluency-trim-plan",
+        description: "Generate disfluency trim plan for speech",
+        requiredFlags: ["audio-url", "script-text"],
+      },
+    },
+  },
+  social: {
+    title: "social media atomic tools",
+    commands: {
+      "xiaohongshu-search-notes": {
+        toolId: "social_search_notes_v3",
+        commandName: "social xiaohongshu-search-notes",
+        description: "Search Xiaohongshu notes",
+        requiredFlags: ["keyword"],
+        aliases: { keywords: "keyword" },
+      },
+      "xiaohongshu-search-users": {
+        toolId: "social_search_users_v1",
+        commandName: "social xiaohongshu-search-users",
+        description: "Search Xiaohongshu users",
+        requiredFlags: ["keyword"],
+        aliases: { keywords: "keyword" },
+      },
+      "xiaohongshu-note-info": {
+        toolId: "social_get_note_info_v2",
+        commandName: "social xiaohongshu-note-info",
+        description: "Get Xiaohongshu note detail",
+        requiredFlags: [],
+      },
+      "douyin-video-search": {
+        toolId: "social_get_video_search_results",
+        commandName: "social douyin-video-search",
+        description: "Search Douyin videos",
+        requiredFlags: ["keyword"],
+      },
+      "douyin-general-search": {
+        toolId: "social_get_general_search_results",
+        commandName: "social douyin-general-search",
+        description: "Run Douyin general search",
+        requiredFlags: ["keyword"],
+      },
+      "douyin-hot-search": {
+        toolId: "social_get_hot_search_list",
+        commandName: "social douyin-hot-search",
+        description: "Get Douyin hot search list",
+        requiredFlags: [],
+      },
+      "douyin-user-info": {
+        toolId: "social_get_user_info_by_sec_user_id",
+        commandName: "social douyin-user-info",
+        description: "Get Douyin user info by sec_user_id",
+        requiredFlags: ["sec-user-id"],
+      },
+      "douyin-homepage-videos": {
+        toolId: "social_get_user_homepage_video_data",
+        commandName: "social douyin-homepage-videos",
+        description: "Get Douyin user homepage videos",
+        requiredFlags: ["sec-user-id"],
+      },
+      "douyin-video-detail": {
+        toolId: "social_get_single_video_data_v2",
+        commandName: "social douyin-video-detail",
+        description: "Get Douyin single video detail",
+        requiredFlags: ["aweme-id"],
+      },
+    },
+  },
+};
+
+function toKebabCase(value) {
+  return value
+    .replace(/^social_/, "")
+    .replace(/_/g, "-");
+}
+
+function toFlagName(value) {
+  return value.replace(/_/g, "-");
+}
+
+function inferAliases(toolId, schemaProperties) {
+  const aliases = {};
+  if (toolId === "social_search_notes_v3" || toolId === "social_search_users_v1") {
+    aliases.keywords = "keyword";
+  }
+
+  if (schemaProperties.sec_uid && !schemaProperties.sec_user_id) {
+    aliases["sec-user-id"] = "sec-uid";
+  }
+
+  if (schemaProperties.url && schemaProperties.share_link) {
+    aliases.url = "share-link";
+  }
+
+  return Object.keys(aliases).length > 0 ? aliases : undefined;
+}
+
+function buildSocialCommandConfig(item) {
+  const properties = item.schema?.properties || {};
+  const required = (item.schema?.required || []).map(toFlagName);
+  return {
+    toolId: item.tool_id,
+    commandName: `social ${toKebabCase(item.tool_id)}`,
+    description: item.description || `Execute ${item.tool_id}`,
+    requiredFlags: required,
+    aliases: inferAliases(item.tool_id, properties),
+  };
+}
+
+export function buildToolRegistry(catalogMap) {
+  const registry = structuredClone(STATIC_TOOL_REGISTRY);
+  const socialCommands = { ...registry.social.commands };
+
+  for (const item of catalogMap.values()) {
+    if (!item.tool_id?.startsWith("social_")) {
+      continue;
+    }
+    const subcommand = toKebabCase(item.tool_id);
+    if (socialCommands[subcommand]) {
+      continue;
+    }
+    socialCommands[subcommand] = buildSocialCommandConfig(item);
+  }
+
+  registry.social.commands = Object.fromEntries(
+    Object.entries(socialCommands).sort(([left], [right]) =>
+      left.localeCompare(right),
+    ),
+  );
+
+  return registry;
+}
+
+export const TOOL_REGISTRY = STATIC_TOOL_REGISTRY;