yuanflow-cli 0.1.5 → 0.1.7

package/src/knowledge-tools.js

@@ -0,0 +1,175 @@
+import { callAtomic, readJsonFile } from './atomic-request.js';
+
+const KNOWLEDGE_NAVIGATE_PATH = '/atomic/agent-rules/navigate';
+const KNOWLEDGE_DOCS_PATH = '/api/knowledge-base/docs';
+
+export function listKnowledgeCommands() {
+  return [
+    {
+      key: 'knowledge.docs',
+      command: 'knowledge docs',
+      kind: 'knowledge-base',
+      description: '读取自媒体知识库公开目录、一级/二级方向和流程说明。',
+      method: 'GET',
+      apiPath: KNOWLEDGE_DOCS_PATH,
+      positionals: [],
+      options: commonOptions({ tokenRequired: false }),
+      requestBody: null,
+      returns: '返回知识库公开目录、能力方向和可用说明。',
+    },
+    knowledgeCommand('entry', '进入知识库，根据用户任务获取领域上下文、推荐能力和方法包。'),
+    knowledgeCommand('packs', '查看某类能力下的方法包。', [
+      { flag: '--capability-code', name: 'capabilityCode', required: false, label: '一级能力 code，例如 topic_generation。' },
+    ]),
+    knowledgeCommand('rules', '查看方法包下的规则方向。', [
+      { flag: '--pack-code', name: 'packCode', required: true, label: '方法包 code。' },
+    ]),
+    knowledgeCommand('rule-detail', '查看单条规则的公开摘要。', [
+      { flag: '--rule-code', name: 'ruleCode', required: true, label: '规则 code。' },
+    ]),
+    knowledgeCommand('evaluate', '获取内容评分维度和优化方向。'),
+  ];
+}
+
+export async function getKnowledgeDocs({ options }) {
+  const response = await callAtomic(KNOWLEDGE_DOCS_PATH, {
+    ...options,
+    method: 'GET',
+    requiresToken: false,
+  });
+  return {
+    ok: true,
+    action: 'docs',
+    endpoint: { method: 'GET', path: KNOWLEDGE_DOCS_PATH, kind: 'knowledge-base' },
+    response,
+  };
+}
+
+export async function navigateKnowledge({ action, options }) {
+  const taskFrame = await buildTaskFrame(options);
+  const params = buildParams(action, options);
+  const body = {
+    action: normalizeAction(action),
+    task_frame: taskFrame,
+    params,
+  };
+  const response = await callAtomic(KNOWLEDGE_NAVIGATE_PATH, {
+    ...options,
+    method: 'POST',
+    body,
+  });
+  return {
+    ok: true,
+    action: normalizeAction(action),
+    endpoint: { method: 'POST', path: KNOWLEDGE_NAVIGATE_PATH, kind: 'knowledge-base' },
+    request: { body },
+    response,
+  };
+}
+
+function knowledgeCommand(action, description, extraOptions = []) {
+  return {
+    key: `knowledge.${action}`,
+    command: `knowledge ${action}`,
+    kind: 'knowledge-base',
+    description,
+    method: 'POST',
+    apiPath: KNOWLEDGE_NAVIGATE_PATH,
+    positionals: [],
+    options: [
+      ...taskFrameOptions(),
+      ...extraOptions,
+      ...commonOptions(),
+    ],
+    requestBody: {
+      action: normalizeAction(action),
+      task_frame: '<由 task-frame 参数组装>',
+      params: '<由命令参数组装>',
+    },
+    returns: '返回当前知识库层级数据和 next_actions，Agent 应按 next_actions 继续查询。',
+  };
+}
+
+function taskFrameOptions() {
+  return [
+    { flag: '--task-intent', name: 'taskIntent', required: false, label: '任务意图，例如 generate_script、generate_copy、evaluate_content。' },
+    { flag: '--output-format', name: 'outputFormat', required: false, label: '输出格式，例如 short_video_script、social_post、any。' },
+    { flag: '--domain', name: 'domain', required: false, label: '内容领域。' },
+    { flag: '--content-goal', name: 'contentGoal', required: false, label: '具体创作或评估目标。' },
+    { flag: '--tone', name: 'tone', required: false, label: '语气风格。' },
+    { flag: '--communication-mode', name: 'communicationMode', required: false, label: '表达方式，例如 口播、图文、文章。' },
+    { flag: '--task-frame-file', name: 'taskFrameFile', required: false, label: '读取 task_frame JSON 文件。' },
+  ];
+}
+
+function commonOptions({ tokenRequired = true } = {}) {
+  return [
+    { flag: '--extra', name: 'extra', required: false, label: 'JSON 字符串，会合并进 params。' },
+    { flag: '--format', name: 'format', required: false, label: 'Agent 调用时建议使用 agent-json。' },
+    { flag: '--dry-run', name: 'dryRun', required: false, label: `仅预览请求映射，不发起真实请求${tokenRequired ? '，也不要求 token' : ''}。` },
+  ];
+}
+
+async function buildTaskFrame(options) {
+  const fromFile = options.named?.['task-frame-file']
+    ? await readJsonFile(options.named['task-frame-file'])
+    : {};
+  return removeUndefined({
+    ...fromFile,
+    task_intent: pick(options, 'task-intent', fromFile.task_intent || 'general'),
+    output_format: pick(options, 'output-format', fromFile.output_format || 'any'),
+    domain: pick(options, 'domain', fromFile.domain || '自媒体运营'),
+    content_goal: pick(options, 'content-goal', fromFile.content_goal || ''),
+    tone: pick(options, 'tone', fromFile.tone || ''),
+    communication_mode: pick(options, 'communication-mode', fromFile.communication_mode || ''),
+  });
+}
+
+function buildParams(action, options) {
+  const params = parseExtra(options.named?.extra);
+  const capabilityCode = cleanOptional(options.named?.['capability-code']);
+  const packCode = cleanOptional(options.named?.['pack-code']);
+  const ruleCode = cleanOptional(options.named?.['rule-code']);
+  if (capabilityCode) params.capability_code = capabilityCode;
+  if (packCode) params.pack_code = packCode;
+  if (ruleCode) params.rule_code = ruleCode;
+  if (action === 'rules' && !params.pack_code) {
+    throw new Error('缺少 --pack-code。');
+  }
+  if (action === 'rule-detail' && !params.rule_code) {
+    throw new Error('缺少 --rule-code。');
+  }
+  return params;
+}
+
+function normalizeAction(action) {
+  return action === 'rule-detail' ? 'rule_detail' : action;
+}
+
+function pick(options, key, fallback) {
+  return cleanOptional(options.named?.[key]) ?? cleanOptional(fallback);
+}
+
+function cleanOptional(value) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+  }
+  return value;
+}
+
+function removeUndefined(payload) {
+  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined));
+}
+
+function parseExtra(value) {
+  if (!value) return {};
+  if (typeof value === 'object') return value;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}

package/src/oss-tools.js

@@ -0,0 +1,181 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { callAtomic } from './atomic-request.js';
+
+const OSS_TEMP_UPLOAD_PATH = '/atomic/oss/temp-upload';
+const OSS_SIGNED_URL_PATH = '/atomic/oss/signed-url';
+const OSS_COPY_PATH = '/atomic/oss/copy';
+
+export function listOssCommands() {
+  return [
+    {
+      key: 'oss.temp-upload',
+      command: 'oss temp-upload',
+      kind: 'oss-atomic',
+      description: '上传本地文件到 Yuan API 临时 OSS bucket，并返回对象 key 和临时访问信息。',
+      method: 'POST',
+      apiPath: OSS_TEMP_UPLOAD_PATH,
+      positionals: [],
+      options: [
+        { flag: '--file', name: 'file', required: true, label: '本地文件路径。' },
+        { flag: '--filename', name: 'filename', required: false, label: '上传时使用的文件名，默认取本地文件名。' },
+        { flag: '--key', name: 'key', required: false, label: '可选 OSS 对象 key。' },
+        { flag: '--content-type', name: 'contentType', required: false, label: '文件 MIME 类型，默认 application/octet-stream。' },
+        ...commonOptions(),
+      ],
+      requestBody: {
+        filename: '<filename>',
+        key: '<optional key>',
+        content_base64: '<base64>',
+        content_type: '<content-type>',
+      },
+      returns: '返回 bucket、key、url、signed_url、expires_at 等字段，字段以后端实际响应为准。',
+    },
+    {
+      key: 'oss.signed-url',
+      command: 'oss signed-url',
+      kind: 'oss-atomic',
+      description: '为已有 OSS 对象生成临时签名访问链接。',
+      method: 'POST',
+      apiPath: OSS_SIGNED_URL_PATH,
+      positionals: [],
+      options: [
+        { flag: '--key', name: 'key', required: true, label: 'OSS 对象 key。' },
+        { flag: '--bucket', name: 'bucket', required: false, label: '可选 bucket，不传则使用后端默认配置。' },
+        { flag: '--ttl-seconds', name: 'ttlSeconds', required: false, label: '签名有效期，最大 86400 秒。' },
+        { flag: '--method', name: 'method', required: false, label: '签名方法：GET、PUT、HEAD。' },
+        ...commonOptions(),
+      ],
+      requestBody: {
+        key: '<key>',
+        bucket: '<optional bucket>',
+        ttl_seconds: 1800,
+        method: 'GET',
+      },
+      returns: '返回签名 URL、过期时间和对象信息，字段以后端实际响应为准。',
+    },
+    {
+      key: 'oss.copy',
+      command: 'oss copy',
+      kind: 'oss-atomic',
+      description: '复制 OSS 对象到目标 key。',
+      method: 'POST',
+      apiPath: OSS_COPY_PATH,
+      positionals: [],
+      options: [
+        { flag: '--source-key', name: 'sourceKey', required: true, label: '源 OSS 对象 key。' },
+        { flag: '--target-key', name: 'targetKey', required: true, label: '目标 OSS 对象 key。' },
+        { flag: '--source-bucket', name: 'sourceBucket', required: false, label: '可选源 bucket。' },
+        { flag: '--target-bucket', name: 'targetBucket', required: false, label: '可选目标 bucket。' },
+        ...commonOptions(),
+      ],
+      requestBody: {
+        source_key: '<source-key>',
+        target_key: '<target-key>',
+        source_bucket: '<optional source bucket>',
+        target_bucket: '<optional target bucket>',
+      },
+      returns: '返回复制后的对象信息，字段以后端实际响应为准。',
+    },
+  ];
+}
+
+export async function tempUpload({ options }) {
+  const filePath = cleanOptional(options.named?.file || options.file);
+  if (!filePath) {
+    throw new Error('缺少 --file。');
+  }
+  const filename = cleanOptional(options.named?.filename) || path.basename(filePath);
+  const contentType = cleanOptional(options.named?.['content-type']) || 'application/octet-stream';
+  const body = {
+    filename,
+    content_base64: options.dryRun ? '<base64 omitted in dry-run>' : (await readFile(filePath)).toString('base64'),
+    content_type: contentType,
+    ...optionalField('key', options.named?.key),
+  };
+  const response = await callAtomic(OSS_TEMP_UPLOAD_PATH, {
+    ...options,
+    method: 'POST',
+    body,
+  });
+  return result('temp-upload', OSS_TEMP_UPLOAD_PATH, body, response);
+}
+
+export async function signedUrl({ options }) {
+  const key = cleanOptional(options.named?.key);
+  if (!key) {
+    throw new Error('缺少 --key。');
+  }
+  const body = {
+    key,
+    ...optionalField('bucket', options.named?.bucket),
+    ...optionalField('ttl_seconds', numberOrString(options.named?.['ttl-seconds'])),
+    ...optionalField('method', cleanOptional(options.named?.method) || 'GET'),
+  };
+  const response = await callAtomic(OSS_SIGNED_URL_PATH, {
+    ...options,
+    method: 'POST',
+    body,
+  });
+  return result('signed-url', OSS_SIGNED_URL_PATH, body, response);
+}
+
+export async function copyObject({ options }) {
+  const sourceKey = cleanOptional(options.named?.['source-key']);
+  const targetKey = cleanOptional(options.named?.['target-key']);
+  if (!sourceKey) {
+    throw new Error('缺少 --source-key。');
+  }
+  if (!targetKey) {
+    throw new Error('缺少 --target-key。');
+  }
+  const body = {
+    source_key: sourceKey,
+    target_key: targetKey,
+    ...optionalField('source_bucket', options.named?.['source-bucket']),
+    ...optionalField('target_bucket', options.named?.['target-bucket']),
+  };
+  const response = await callAtomic(OSS_COPY_PATH, {
+    ...options,
+    method: 'POST',
+    body,
+  });
+  return result('copy', OSS_COPY_PATH, body, response);
+}
+
+function commonOptions() {
+  return [
+    { flag: '--format', name: 'format', required: false, label: 'Agent 调用时建议使用 agent-json。' },
+    { flag: '--dry-run', name: 'dryRun', required: false, label: '仅预览请求映射，不发起真实请求，也不要求 token。' },
+  ];
+}
+
+function result(action, endpointPath, body, response) {
+  return {
+    ok: true,
+    action,
+    endpoint: { method: 'POST', path: endpointPath, kind: 'oss-atomic' },
+    request: { body },
+    response,
+  };
+}
+
+function optionalField(name, value) {
+  const cleaned = cleanOptional(value);
+  return cleaned === undefined ? {} : { [name]: cleaned };
+}
+
+function cleanOptional(value) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+  }
+  return value;
+}
+
+function numberOrString(value) {
+  const cleaned = cleanOptional(value);
+  if (cleaned === undefined) return undefined;
+  return /^-?\d+$/.test(String(cleaned)) ? Number(cleaned) : cleaned;
+}