@guanwenai/high-tech-project-cli 0.1.0

package/scripts/services/finance.mjs

@@ -0,0 +1,145 @@
+import { CliError } from '../core/errors.mjs';
+import {
+  itemsInput as sharedItemsInput,
+  objectInput as sharedObjectInput,
+  valueOf,
+  withJavaMethod,
+} from './shared.mjs';
+
+const REQUIRED_CONTEXT = ['gatewayUrl', 'uuid'];
+
+function objectInput(input) {
+  return sharedObjectInput(input);
+}
+
+function itemsInput(input) {
+  return sharedItemsInput(input);
+}
+
+function listCommand(name, path, javaMethod, body = (_input, context) => ({ uuid: context.uuid })) {
+  return withJavaMethod({
+    name, method: 'POST', path, idempotent: true, multipart: false,
+    requiredContext: REQUIRED_CONTEXT, validate: objectInput,
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path, body: body(input, context), idempotent: true,
+    }),
+  }, javaMethod);
+}
+
+export const commands = [
+  listCommand('finance.list-fees', '/api/project-writing/fee-detail/list'),
+  listCommand('finance.list-income', '/api/project-writing/product-income/list'),
+  listCommand('finance.list-rd-funds', '/api/project-writing/rd-fund-situation/list', 'project_writing_rd_fund_situation_list'),
+  {
+    name: 'finance.save-operation-status',
+    method: 'POST',
+    path: '/api/project-writing/operation-status/create',
+    idempotent: false,
+    multipart: false,
+    requiredContext: REQUIRED_CONTEXT,
+    validate: itemsInput,
+    handler: async ({ client, context, input }) => {
+      const results = [];
+      for (const item of input.items) {
+        results.push(await client.request({
+          method: 'POST',
+          path: item.id
+            ? '/api/project-writing/operation-status/update'
+            : '/api/project-writing/operation-status/create',
+          body: { ...item, uuid: item.uuid ?? context.uuid },
+          idempotent: false,
+        }));
+      }
+      return results;
+    },
+  },
+  ...[
+    ['fee', 'fee-detail', 'project_writing_fee_detail'],
+    ['operation', 'operation-status', 'project_writing_operation_status'],
+    ['income', 'product-income', 'project_writing_product_income'],
+  ].flatMap(([name, resource, javaPrefix]) => [
+    {
+      name: `finance.${name}-create`, method: 'POST', path: `/api/project-writing/${resource}/create`,
+      idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT,
+      validate: (input) => {
+        const value = objectInput(input);
+        if (value.data === null || Array.isArray(value.data) || typeof value.data !== 'object') {
+          throw new CliError('ARGUMENT_INVALID', 'data 必须是对象');
+        }
+        return value;
+      },
+      javaMethod: `${javaPrefix}_create`,
+      handler: async ({ client, context, input }) => await client.request({
+        method: 'POST', path: `/api/project-writing/${resource}/create`, idempotent: false,
+        body: { ...input.data, uuid: context.uuid },
+      }),
+    },
+    {
+      name: `finance.${name}-update`, method: 'POST', path: `/api/project-writing/${resource}/update`,
+      idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT,
+      validate: (input) => {
+        const value = objectInput(input);
+        if (value.data === null || Array.isArray(value.data) || typeof value.data !== 'object'
+          || !Number.isSafeInteger(value.data.id) || value.data.id <= 0) {
+          throw new CliError('ARGUMENT_INVALID', 'data 必须是包含正整数 id 的对象');
+        }
+        return value;
+      },
+      javaMethod: `${javaPrefix}_update`,
+      handler: async ({ client, context, input }) => await client.request({
+        method: 'POST', path: `/api/project-writing/${resource}/update`, idempotent: false,
+        body: { ...input.data, uuid: context.uuid },
+      }),
+    },
+    {
+      name: `finance.${name}-batch-save`, method: 'POST', path: `/api/project-writing/${resource}/batch-save`,
+      idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT, validate: itemsInput,
+      javaMethod: `${javaPrefix}_batch_save`,
+      handler: async ({ client, context, input }) => await client.request({
+        method: 'POST', path: `/api/project-writing/${resource}/batch-save`, idempotent: false,
+        body: input.items.map((item) => ({ ...item, uuid: item.uuid ?? context.uuid })),
+      }),
+    },
+  ]).map((definition) => withJavaMethod(definition, definition.javaMethod)),
+  withJavaMethod({
+    name: 'finance.fee-list', method: 'POST', path: '/api/project-writing/fee-detail/list',
+    idempotent: true, multipart: false, requiredContext: REQUIRED_CONTEXT,
+    validate: objectInput, javaMethod: 'project_writing_fee_detail_list',
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/fee-detail/list', idempotent: true,
+      body: { uuid: context.uuid, ...(input.year !== undefined ? { year: input.year } : {}) },
+    }),
+  }, 'project_writing_fee_detail_list'),
+  withJavaMethod({
+    name: 'finance.operation-list', method: 'POST', path: '/api/project-writing/operation-status/list',
+    idempotent: true, multipart: false, requiredContext: REQUIRED_CONTEXT,
+    validate: objectInput, javaMethod: 'project_writing_operation_status_list',
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/operation-status/list', idempotent: true,
+      body: { uuid: context.uuid, ...(input.year !== undefined ? { year: input.year } : {}) },
+    }),
+  }, 'project_writing_operation_status_list'),
+  withJavaMethod({
+    name: 'finance.income-list', method: 'POST', path: '/api/project-writing/product-income/list',
+    idempotent: true, multipart: false, requiredContext: REQUIRED_CONTEXT,
+    validate: objectInput, javaMethod: 'project_writing_product_income_list',
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/product-income/list', idempotent: true,
+      body: {
+        uuid: context.uuid,
+        ...(valueOf(input, 'product_code', 'productCode') !== undefined
+          ? { productCode: valueOf(input, 'product_code', 'productCode') } : {}),
+        ...(input.year !== undefined ? { year: input.year } : {}),
+      },
+    }),
+  }, 'project_writing_product_income_list'),
+  withJavaMethod({
+    name: 'finance.rd-fund-batch-save', method: 'POST', path: '/api/project-writing/rd-fund-situation/batch-save',
+    idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT, validate: itemsInput,
+    javaMethod: 'project_writing_rd_fund_situation_batch_save',
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/rd-fund-situation/batch-save', idempotent: false,
+      body: input.items.map((item) => ({ ...item, uuid: item.uuid ?? context.uuid })),
+    }),
+  }, 'project_writing_rd_fund_situation_batch_save'),
+];

package/scripts/services/ipr.mjs

@@ -0,0 +1,121 @@
+import { CliError } from '../core/errors.mjs';
+import {
+  PROJECT_CONTEXT,
+  contentInput,
+  createFileCommand,
+  idsInput,
+  itemsInput,
+  objectInput as sharedObjectInput,
+  pageInput,
+  positiveId,
+  requiredString,
+  resolveSmartImportFiles,
+  valueOf,
+  withJavaMethod,
+} from './shared.mjs';
+
+function objectInput(input) {
+  return sharedObjectInput(input);
+}
+
+function fileCreateInput(input) {
+  const value = objectInput(input);
+  requiredString(valueOf(value, 'file_name', 'fileName'), 'file_name');
+  requiredString(valueOf(value, 'file_path', 'filePath'), 'file_path');
+  return value;
+}
+
+function smartImportInput(input) {
+  const value = objectInput(input);
+  if (!Array.isArray(value.items) || value.items.length === 0
+    || value.items.some((item) => item === null || Array.isArray(item) || typeof item !== 'object')) {
+    throw new CliError('ARGUMENT_INVALID', 'items 必须是非空对象数组');
+  }
+  value.items.forEach((item) => {
+    positiveId(valueOf(item, 'ipr_id', 'iprId'), 'ipr_id');
+    requiredString(valueOf(item, 'file_name', 'fileName'), 'file_name');
+  });
+  return value;
+}
+
+function command({ name, path, idempotent, validate = objectInput, body, javaMethod, handler }) {
+  return withJavaMethod({
+    name, method: 'POST', path, idempotent, requiredContext: PROJECT_CONTEXT, validate,
+    handler: handler ?? (async ({ client, context, input }) => await client.request({
+      method: 'POST', path, body: body(input, context), idempotent,
+    })),
+  }, javaMethod);
+}
+
+const saveCommand = {
+  name: 'ipr.save', method: 'POST', path: '/api/project-writing/ipr/create', idempotent: false,
+  requiredContext: PROJECT_CONTEXT, validate: objectInput,
+  handler: async ({ client, context, input }) => await client.request({
+    method: 'POST',
+    path: input.id ? '/api/project-writing/ipr/update' : '/api/project-writing/ipr/create',
+    body: { ...input, uuid: context.uuid }, idempotent: false,
+  }),
+};
+
+export const commands = [
+  command({
+    name: 'ipr.list', path: '/api/project-writing/ipr/page', idempotent: true, validate: pageInput,
+    body: (input, context) => ({
+      uuid: context.uuid, pageNumber: input.pageNumber ?? input.page_number ?? 1,
+      pageSize: input.pageSize ?? input.page_size ?? 20, ...input,
+    }),
+  }),
+  saveCommand,
+  command({
+    name: 'ipr.save-batch', path: '/api/project-writing/ipr/batch-save', idempotent: false,
+    validate: itemsInput, javaMethod: 'project_writing_ipr_batch_save',
+    body: (input, context) => input.items.map((item) => ({ ...item, uuid: item.uuid ?? context.uuid })),
+  }),
+  command({
+    name: 'ipr.list-all', path: '/api/project-writing/ipr/list', idempotent: true,
+    javaMethod: 'project_writing_ipr_list', body: (input, context) => ({ ...input, uuid: context.uuid }),
+  }),
+  command({
+    name: 'ipr.files', path: '/api/project-writing/ipr-file/list', idempotent: true,
+    body: (_input, context) => ({ uuid: context.uuid }),
+  }),
+  command({
+    name: 'ipr.submissions', path: '/api/project-writing/ipr-submit/list', idempotent: true,
+    body: (_input, context) => ({ uuid: context.uuid }),
+  }),
+  command({
+    name: 'ipr.delete-by-uuid', path: '/api/project-writing/ipr/batch-delete-by-uuid', idempotent: false,
+    javaMethod: 'project_writing_ipr_batch_delete_by_uuid', validate: idsInput,
+    body: (input, context) => input.ids.map((id) => ({ uuid: context.uuid, items: [{ id }] })),
+  }),
+  withJavaMethod(createFileCommand({
+    name: 'ipr.file-create', path: '/api/project-writing/ipr-file/create', validate: fileCreateInput,
+  }), 'project_writing_ipr_file_create'),
+  command({
+    name: 'ipr.file-smart-import', path: '/api/project-writing/ipr-file/smart-import', idempotent: false,
+    javaMethod: 'project_writing_ipr_file_smart_import', validate: smartImportInput,
+    handler: async ({ client, context, input, baseDir }) => {
+      const names = input.items.map((item) => valueOf(item, 'file_name', 'fileName'));
+      const resolved = await resolveSmartImportFiles({ client, context, baseDir, fileNames: names });
+      const byName = new Map(resolved.files.map((file) => [file.fileName, file]));
+      const items = input.items.map((item) => {
+        const fileName = valueOf(item, 'file_name', 'fileName');
+        const reference = byName.get(fileName);
+        return { iprId: valueOf(item, 'ipr_id', 'iprId'), fileName, ...(reference ? { filePath: reference.filePath } : {}) };
+      });
+      return await client.request({
+        method: 'POST', path: '/api/project-writing/ipr-file/smart-import', idempotent: false,
+        body: { uuid: context.uuid, items },
+      });
+    },
+  }),
+  command({
+    name: 'ipr.situation-get', path: '/api/project-writing/ipr-situation/detail', idempotent: true,
+    javaMethod: 'project_writing_ipr_situation_get', body: (_input, context) => ({ uuid: context.uuid }),
+  }),
+  command({
+    name: 'ipr.situation-save', path: '/api/project-writing/ipr-situation/batch-save', idempotent: false,
+    javaMethod: 'project_writing_ipr_situation_batch_save', validate: contentInput,
+    body: (input, context) => ({ uuid: context.uuid, content: valueOf(input, 'content') }),
+  }),
+];

package/scripts/services/knowledge.mjs

@@ -0,0 +1,205 @@
+import { readFile } from 'node:fs/promises';
+import { basename, isAbsolute } from 'node:path';
+
+import { CliError } from '../core/errors.mjs';
+import { resolveWithinBase } from '../core/files.mjs';
+
+const REQUIRED_CONTEXT = ['gatewayUrl'];
+
+function objectInput(input) {
+  if (input === null || Array.isArray(input) || typeof input !== 'object') {
+    throw new CliError('ARGUMENT_INVALID', '命令输入必须是对象');
+  }
+  return input;
+}
+
+function identifier(value, field) {
+  if ((typeof value !== 'string' && typeof value !== 'number') || !String(value).trim()) {
+    throw new CliError('ARGUMENT_INVALID', `${field} 不能为空`);
+  }
+  return value;
+}
+
+function encoded(value, field) {
+  return encodeURIComponent(String(identifier(value, field)));
+}
+
+function kbInput(input) {
+  const value = objectInput(input);
+  identifier(value.kbId, 'kbId');
+  return value;
+}
+
+function folderInput(input) {
+  const value = kbInput(input);
+  identifier(value.folderId, 'folderId');
+  return value;
+}
+
+function documentInput(input) {
+  const value = kbInput(input);
+  identifier(value.documentId, 'documentId');
+  return value;
+}
+
+function tagsInput(input) {
+  const value = documentInput(input);
+  if (!Array.isArray(value.tags) || value.tags.some((tag) => typeof tag !== 'string')) {
+    throw new CliError('ARGUMENT_INVALID', 'tags 必须是字符串数组');
+  }
+  return value;
+}
+
+function projectBindInput(input) {
+  const value = objectInput(input);
+  const projectId = Number(value.workId);
+  if (!Number.isSafeInteger(projectId) || projectId <= 0
+    || typeof value.workName !== 'string' || !value.workName.trim()
+    || typeof value.customerName !== 'string' || !value.customerName.trim()) {
+    throw new CliError('ARGUMENT_INVALID', '项目绑定参数无效');
+  }
+  return value;
+}
+
+function uploadInput(input) {
+  const value = kbInput(input);
+  if (typeof value.uuid !== 'string' || !value.uuid.trim()) {
+    throw new CliError('ARGUMENT_INVALID', 'uuid 不能为空');
+  }
+  if (typeof value.file !== 'string' || !value.file.trim() || isAbsolute(value.file)
+    || value.file.split(/[\\/]/u).includes('..')) {
+    throw new CliError('ARGUMENT_INVALID', 'file 必须是工作目录内的相对路径');
+  }
+  if (value.tags !== undefined
+    && (!Array.isArray(value.tags) || value.tags.some((tag) => typeof tag !== 'string'))) {
+    throw new CliError('ARGUMENT_INVALID', 'tags 必须是字符串数组');
+  }
+  if (value.tagTemplateId !== undefined
+    && (!Number.isSafeInteger(value.tagTemplateId) || value.tagTemplateId <= 0)) {
+    throw new CliError('ARGUMENT_INVALID', 'tagTemplateId 必须是正整数');
+  }
+  return value;
+}
+
+function definition(name, method, path, idempotent, validate, handler) {
+  return {
+    name, method, path, idempotent, multipart: false,
+    requiredContext: REQUIRED_CONTEXT, validate, handler,
+  };
+}
+
+function bodyCommand(name, path, idempotent, validate = objectInput) {
+  return definition(
+    name, 'POST', path, idempotent, validate,
+    async ({ client, input }) => await client.request({
+      method: 'POST', path, body: input, idempotent,
+    }),
+  );
+}
+
+function documentAction(name, action, validate = documentInput) {
+  const declaredPath = `/api/knowledge/{kbId}/documents/{documentId}/${action}`;
+  return definition(
+    name, 'POST', declaredPath, false, validate,
+    async ({ client, input }) => {
+      const { kbId, documentId, ...body } = input;
+      const path = `/api/knowledge/${encoded(kbId, 'kbId')}/documents/${encoded(documentId, 'documentId')}/${action}`;
+      const request = { method: 'POST', path, idempotent: false };
+      if (Object.keys(body).length > 0) request.body = body;
+      return await client.request(request);
+    },
+  );
+}
+
+export const commands = [
+  definition(
+    'knowledge.documents-page', 'GET', '/api/knowledge/{kbId}/documents/page', true, kbInput,
+    async ({ client, input }) => {
+      const { kbId, ...query } = input;
+      return await client.request({
+        method: 'GET', path: `/api/knowledge/${encoded(kbId, 'kbId')}/documents/page`,
+        query, idempotent: true,
+      });
+    },
+  ),
+  definition(
+    'knowledge.folders-tree', 'GET', '/api/knowledge/{kbId}/folders/tree', true, kbInput,
+    async ({ client, input }) => await client.request({
+      method: 'GET', path: `/api/knowledge/${encoded(input.kbId, 'kbId')}/folders/tree`,
+      idempotent: true,
+    }),
+  ),
+  definition(
+    'knowledge.folder-create', 'POST', '/api/knowledge/{kbId}/folders/create', false, kbInput,
+    async ({ client, input }) => {
+      const { kbId, ...body } = input;
+      return await client.request({
+        method: 'POST', path: `/api/knowledge/${encoded(kbId, 'kbId')}/folders/create`,
+        body, idempotent: false,
+      });
+    },
+  ),
+  definition(
+    'knowledge.folder-delete', 'POST', '/api/knowledge/{kbId}/folders/{folderId}/delete', false, folderInput,
+    async ({ client, input }) => await client.request({
+      method: 'POST',
+      path: `/api/knowledge/${encoded(input.kbId, 'kbId')}/folders/${encoded(input.folderId, 'folderId')}/delete`,
+      idempotent: false,
+    }),
+  ),
+  documentAction('knowledge.document-retry', 'retry'),
+  documentAction('knowledge.document-delete', 'delete'),
+  documentAction('knowledge.document-move', 'move'),
+  documentAction('knowledge.document-update-tags', 'tags/update', tagsInput),
+  bodyCommand('knowledge.tag-template-list', '/api/project-writing/kb-tag-template/list', true),
+  bodyCommand('knowledge.tag-template-create', '/api/project-writing/kb-tag-template/create', false),
+  bodyCommand('knowledge.tag-template-update', '/api/project-writing/kb-tag-template/update', false),
+  bodyCommand('knowledge.tag-template-delete', '/api/project-writing/kb-tag-template/delete', false),
+  bodyCommand('knowledge.tag-template-default', '/api/project-writing/kb-tag-template/get-default', true),
+  definition(
+    'knowledge.project-bind', 'POST', '/api/project-writing/bind/create', false, projectBindInput,
+    async ({ client, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/bind/create', idempotent: false,
+      body: {
+        projectId: Number(input.workId),
+        projectName: input.workName,
+        customerName: input.customerName,
+      },
+    }),
+  ),
+  {
+    name: 'knowledge.upload', method: 'POST', path: '/api/project-writing/file/upload',
+    idempotent: false, multipart: true, requiredContext: REQUIRED_CONTEXT, validate: uploadInput,
+    handler: async ({ client, input, baseDir }) => {
+      if (typeof baseDir !== 'string' || !baseDir) {
+        throw new CliError('CONFIG_MISSING', '知识库上传缺少 baseDir');
+      }
+      const resolvedPath = resolveWithinBase(input.file, baseDir);
+      let content;
+      try {
+        content = await readFile(resolvedPath);
+      } catch {
+        throw new CliError('FILE_NOT_FOUND', '知识库上传文件不存在', {
+          relativePath: input.file, baseDir, resolvedPath,
+        });
+      }
+      const fileName = basename(resolvedPath);
+      const formData = new FormData();
+      formData.append('uuid', input.uuid);
+      formData.append('file', new Blob([content]), fileName);
+      const uploaded = await client.upload({ path: '/api/project-writing/file/upload', formData });
+      const url = typeof uploaded === 'string' ? uploaded : uploaded?.filePath ?? uploaded?.url;
+      if (!url) throw new CliError('BUSINESS_ERROR', '文件上传未返回地址');
+      return await client.request({
+        method: 'POST', path: '/api/project-writing/file/upload-to-kb', idempotent: false,
+        body: {
+          kbId: input.kbId,
+          fileName,
+          url,
+          tags: input.tags ?? [],
+          ...(input.tagTemplateId === undefined ? {} : { tagTemplateId: input.tagTemplateId }),
+        },
+      });
+    },
+  },
+];