@guanwenai/high-tech-project-cli 0.1.0

package/scripts/services/material.mjs

@@ -0,0 +1,252 @@
+import { createWriteStream } from 'node:fs';
+import { mkdir, readFile, rename, rm } from 'node:fs/promises';
+import { basename, dirname, extname, isAbsolute } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+
+import { CliError } from '../core/errors.mjs';
+import { resolveWithinBase } from '../core/files.mjs';
+import {
+  objectInput as sharedObjectInput,
+  positiveId,
+  valueOf,
+  withJavaMethod,
+} from './shared.mjs';
+
+const REQUIRED_CONTEXT = ['gatewayUrl', 'uuid'];
+const ROUTES = {
+  supplement: {
+    list: '/api/project-writing/supplement-file/list',
+    save: '/api/project-writing/supplement-file/update',
+    delete: '/api/project-writing/supplement-file/delete-batch',
+  },
+  signature: {
+    list: '/api/project-writing/signature-file/list',
+    save: '/api/project-writing/signature-file/create',
+    delete: '/api/project-writing/signature-file/delete-batch',
+  },
+  system: {
+    list: '/api/project-writing/system-manage-file/list',
+    save: '/api/project-writing/system-manage-file/create',
+    delete: '/api/project-writing/system-manage-file/delete-batch',
+  },
+};
+
+function objectInput(input) {
+  return sharedObjectInput(input);
+}
+
+function kindInput(input) {
+  const value = objectInput(input);
+  if (!Object.hasOwn(ROUTES, value.kind)) {
+    throw new CliError('ARGUMENT_INVALID', 'kind 必须是 supplement、signature 或 system');
+  }
+  return value;
+}
+
+function idArray(value, field) {
+  if (!Array.isArray(value) || value.length === 0
+    || value.some((id) => !Number.isSafeInteger(id) || id <= 0)) {
+    throw new CliError('ARGUMENT_INVALID', `${field} 必须是非空正整数数组`);
+  }
+}
+
+function deleteInput(input) {
+  const value = kindInput(input);
+  idArray(value.ids, 'ids');
+  return value;
+}
+
+function safeRelativePath(value, field) {
+  if (typeof value !== 'string' || !value.trim() || isAbsolute(value)
+    || value.split(/[\\/]/u).includes('..')) {
+    throw new CliError('ARGUMENT_INVALID', `${field} 必须是工作目录内的相对路径`);
+  }
+}
+
+function uploadInput(input) {
+  const value = kindInput(input);
+  safeRelativePath(value.file, 'file');
+  if (typeof value.fileCode !== 'string' || !value.fileCode.trim()) {
+    throw new CliError('ARGUMENT_INVALID', '上传材料需要 fileCode');
+  }
+  if (value.kind === 'signature' && (typeof value.bizType !== 'string' || !value.bizType.trim())) {
+    throw new CliError('ARGUMENT_INVALID', '签章材料需要 bizType');
+  }
+  return value;
+}
+
+function generateInput(input) {
+  const value = kindInput(input);
+  if (value.kind !== 'system') {
+    throw new CliError('ARGUMENT_INVALID', '仅 system 材料支持生成递交文件');
+  }
+  idArray(value.fileIds, 'fileIds');
+  if (typeof value.fileCode !== 'string' || !value.fileCode.trim()) {
+    throw new CliError('ARGUMENT_INVALID', '生成材料需要 fileCode');
+  }
+  return value;
+}
+
+function downloadInput(input) {
+  const value = objectInput(input);
+  if (typeof value.fileUrl !== 'string' || !value.fileUrl.trim()
+    || typeof value.fileName !== 'string' || !value.fileName.trim()) {
+    throw new CliError('ARGUMENT_INVALID', '下载需要 fileUrl 和 fileName');
+  }
+  safeRelativePath(value.target, 'target');
+  return value;
+}
+
+export async function downloadAtomically({ client, input, baseDir }) {
+  if (typeof baseDir !== 'string' || !baseDir) {
+    throw new CliError('CONFIG_MISSING', '文件下载缺少 baseDir');
+  }
+  const resolvedPath = resolveWithinBase(input.target, baseDir);
+  const targetDirectory = dirname(resolvedPath);
+  await mkdir(targetDirectory, { recursive: true });
+  const temporaryPath = `${resolvedPath}.${randomUUID()}.tmp`;
+  const response = await client.download({
+    path: '/api/project-writing/file/download',
+    method: 'POST',
+    body: { fileUrl: input.fileUrl, fileName: input.fileName },
+  });
+  if (!response?.body || typeof response.body.getReader !== 'function') {
+    throw new CliError('FILE_WRITE_FAILED', '下载响应缺少文件流', {
+      relativePath: input.target, baseDir, resolvedPath,
+    });
+  }
+
+  let bytesWritten = 0;
+  const counter = new Transform({
+    transform(chunk, _encoding, callback) {
+      bytesWritten += chunk.length;
+      callback(null, chunk);
+    },
+  });
+  try {
+    await pipeline(
+      Readable.fromWeb(response.body),
+      counter,
+      createWriteStream(temporaryPath, { flags: 'wx' }),
+    );
+    await rename(temporaryPath, resolvedPath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => undefined);
+    throw new CliError('FILE_WRITE_FAILED', '文件下载或写入失败', {
+      relativePath: input.target,
+      baseDir,
+      resolvedPath,
+      cause: error instanceof Error ? error.message : String(error),
+    });
+  }
+  return { relativePath: input.target, bytesWritten };
+}
+
+export const commands = [
+  {
+    name: 'material.list', method: 'POST', path: ROUTES.supplement.list,
+    idempotent: true, multipart: false, requiredContext: REQUIRED_CONTEXT, validate: kindInput,
+    handler: async ({ client, context, input }) => {
+      const { kind, ...filters } = input;
+      return await client.request({
+        method: 'POST', path: ROUTES[kind].list, idempotent: true,
+        body: { uuid: context.uuid, ...filters },
+      });
+    },
+  },
+  withJavaMethod({
+    name: 'material.supplement-list', method: 'POST', path: '/api/project-writing/supplement-file/list',
+    idempotent: true, multipart: false, requiredContext: REQUIRED_CONTEXT, validate: objectInput,
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/supplement-file/list', idempotent: true,
+      body: {
+        uuid: context.uuid,
+        ...(input.ids ? { ids: input.ids } : {}),
+        ...(input.fileType !== undefined || input.file_type !== undefined
+          ? { fileType: input.fileType ?? input.file_type } : {}),
+        ...(input.fileCode !== undefined || input.file_code !== undefined
+          ? { fileCode: input.fileCode ?? input.file_code } : {}),
+        ...(input.fileFormat !== undefined || input.file_format !== undefined
+          ? { fileFormat: input.fileFormat ?? input.file_format } : {}),
+      },
+    }),
+  }, 'project_writing_supplement_file_list'),
+  withJavaMethod({
+    name: 'material.supplement-update', method: 'POST', path: '/api/project-writing/supplement-file/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') {
+        throw new CliError('ARGUMENT_INVALID', 'data 必须是对象');
+      }
+      positiveId(value.data.id, 'data.id');
+      return value;
+    },
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/supplement-file/update', idempotent: false,
+      body: { ...input.data, uuid: context.uuid },
+    }),
+  }, 'project_writing_supplement_file_update'),
+  {
+    name: 'material.upload', method: 'POST', path: '/api/project-writing/file/upload',
+    idempotent: false, multipart: true, requiredContext: REQUIRED_CONTEXT, validate: uploadInput,
+    handler: async ({ client, context, 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', context.uuid);
+      formData.append('file', new Blob([content]), fileName);
+      const uploaded = await client.upload({ path: '/api/project-writing/file/upload', formData });
+      const filePath = typeof uploaded === 'string' ? uploaded : uploaded?.filePath;
+      if (!filePath) {
+        throw new CliError('BUSINESS_ERROR', '文件上传未返回 filePath');
+      }
+      const { kind, file, ...metadata } = input;
+      const extension = extname(fileName).slice(1).toLowerCase();
+      return await client.request({
+        method: 'POST', path: ROUTES[kind].save, idempotent: false,
+        body: {
+          ...metadata,
+          uuid: context.uuid,
+          fileName,
+          filePath,
+          fileSize: content.length,
+          ...(extension ? { fileFormat: extension } : {}),
+        },
+      });
+    },
+  },
+  {
+    name: 'material.delete-batch', method: 'POST', path: ROUTES.supplement.delete,
+    idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT, validate: deleteInput,
+    handler: async ({ client, input }) => await client.request({
+      method: 'POST', path: ROUTES[input.kind].delete, body: input.ids, idempotent: false,
+    }),
+  },
+  {
+    name: 'material.generate', method: 'POST', path: '/api/project-writing/system-manage-submit/generate',
+    idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT, validate: generateInput,
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/system-manage-submit/generate', idempotent: false,
+      body: { uuid: context.uuid, fileIds: input.fileIds, fileCode: input.fileCode },
+    }),
+  },
+  {
+    name: 'material.download', method: 'POST', path: '/api/project-writing/file/download',
+    idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT, validate: downloadInput,
+    handler: downloadAtomically,
+  },
+];

package/scripts/services/people.mjs

@@ -0,0 +1,160 @@
+import { CliError } from '../core/errors.mjs';
+import {
+  PROJECT_CONTEXT,
+  contentInput,
+  createFileCommand,
+  idsInput as sharedIdsInput,
+  itemsInput as sharedItemsInput,
+  objectInput as sharedObjectInput,
+  resolveSmartImportFiles,
+  requiredString,
+  valueOf,
+  withJavaMethod,
+} from './shared.mjs';
+
+function objectInput(input) {
+  return sharedObjectInput(input);
+}
+
+function pageInput(input) {
+  const value = objectInput(input);
+  for (const field of ['pageNumber', 'pageSize']) {
+    if (value[field] !== undefined
+      && (!Number.isSafeInteger(value[field]) || value[field] <= 0)) {
+      throw new CliError('ARGUMENT_INVALID', `${field} 必须是正整数`);
+    }
+  }
+  return value;
+}
+
+function itemsInput(input) {
+  return sharedItemsInput(input);
+}
+
+function idsInput(input) {
+  return sharedIdsInput(input);
+}
+
+function command({ name, path, idempotent, validate = objectInput, body, javaMethod, handler: customHandler }) {
+  return withJavaMethod({
+    name,
+    method: 'POST',
+    path,
+    idempotent,
+    requiredContext: PROJECT_CONTEXT,
+    validate,
+    handler: customHandler ?? (async ({ client, context, input }) => await client.request({
+      method: 'POST', path, body: body(input, context), idempotent,
+    })),
+  }, javaMethod);
+}
+
+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);
+  const names = valueOf(value, 'file_names', 'fileNames');
+  if (names !== undefined && (!Array.isArray(names) || names.some((name) => typeof name !== 'string'))) {
+    throw new CliError('ARGUMENT_INVALID', 'file_names 必须是字符串数组');
+  }
+  return value;
+}
+
+export const commands = [
+  command({
+    name: 'people.list', path: '/api/project-writing/person/page', idempotent: true,
+    validate: pageInput,
+    body: (input, context) => ({
+      uuid: context.uuid,
+      pageNumber: input.pageNumber ?? 1,
+      pageSize: input.pageSize ?? 20,
+      ...input,
+    }),
+  }),
+  command({
+    name: 'people.list-all', path: '/api/project-writing/person/list', idempotent: true,
+    javaMethod: 'project_writing_person_list',
+    body: (input, context) => ({ ...input, uuid: context.uuid }),
+  }),
+  command({
+    name: 'people.save-batch', path: '/api/project-writing/person/batch-save', idempotent: false,
+    validate: itemsInput,
+    javaMethod: 'project_writing_person_batch_save',
+    body: (input, context) => input.items.map((item) => ({
+      ...item, chooseFlag: true, uuid: item.uuid ?? context.uuid,
+    })),
+  }),
+  command({
+    name: 'people.delete-batch', path: '/api/project-writing/person/batch-delete', idempotent: false,
+    validate: idsInput,
+    body: (input) => input.ids,
+  }),
+  command({
+    name: 'people.files', path: '/api/project-writing/person-file/list', idempotent: true,
+    body: (_input, context) => ({ uuid: context.uuid }),
+  }),
+  command({
+    name: 'people.submissions', path: '/api/project-writing/person-submit/list', idempotent: true,
+      body: (_input, context) => ({ uuid: context.uuid }),
+  }),
+  command({
+    name: 'people.save-all', path: '/api/project-writing/person/batch-save', idempotent: false,
+    validate: itemsInput, javaMethod: 'project_writing_person_batch_save_all',
+    body: (input, context) => input.items.map((item) => ({
+      ...item, chooseFlag: false, uuid: item.uuid ?? context.uuid,
+    })),
+  }),
+  command({
+    name: 'people.chart-stats', path: '/api/project-writing/person/chart-stats', idempotent: true,
+    javaMethod: 'project_writing_person_chart_stats',
+    body: (_input, context) => ({ uuid: context.uuid }),
+  }),
+  command({
+    name: 'people.situation-get', path: '/api/project-writing/person-situation/detail', idempotent: true,
+    javaMethod: 'project_writing_person_situation_get',
+    body: (_input, context) => ({ uuid: context.uuid }),
+  }),
+  command({
+    name: 'people.situation-save', path: '/api/project-writing/person-situation/batch-save', idempotent: false,
+    javaMethod: 'project_writing_person_situation_batch_save', validate: contentInput,
+    body: (input, context) => ({ uuid: context.uuid, content: valueOf(input, 'content') }),
+  }),
+  withJavaMethod(createFileCommand({
+    name: 'people.file-create', path: '/api/project-writing/person-file/create',
+    idField: null, validate: fileCreateInput,
+  }), 'project_writing_person_file_create'),
+  command({
+    name: 'people.file-smart-import', path: '/api/project-writing/person-file/smart-import', idempotent: false,
+    javaMethod: 'project_writing_person_file_smart_import', validate: smartImportInput,
+    body: (input, context) => ({
+      uuid: context.uuid,
+      ...(context.tenantCode ? { tenantCode: context.tenantCode } : {}),
+      ...(valueOf(input, 'file_names', 'fileNames') ? { fileNames: valueOf(input, 'file_names', 'fileNames') } : {}),
+      ...(input.files ? { files: input.files } : {}),
+    }),
+    handler: async ({ client, context, input, baseDir }) => {
+      const names = valueOf(input, 'file_names', 'fileNames') ?? [];
+      const resolved = await resolveSmartImportFiles({ client, context, baseDir, fileNames: names });
+      return await client.request({
+        method: 'POST', path: '/api/project-writing/person-file/smart-import', idempotent: false,
+        body: {
+          uuid: context.uuid,
+          ...(context.tenantCode ? { tenantCode: context.tenantCode } : {}),
+          ...(resolved.files.length ? { files: resolved.files } : {}),
+          ...(resolved.unresolved.length ? { fileNames: resolved.unresolved } : {}),
+          ...(input.files ? { files: input.files } : {}),
+        },
+      });
+    },
+  }),
+  command({
+    name: 'people.delete-by-uuid', path: '/api/project-writing/person/batch-delete-by-uuid', idempotent: false,
+    javaMethod: 'project_writing_person_batch_delete_by_uuid', validate: idsInput,
+    body: (input, context) => input.ids.map((id) => ({ uuid: context.uuid, items: [{ id }] })),
+  }),
+];

package/scripts/services/policy.mjs

@@ -0,0 +1,209 @@
+import { CliError } from '../core/errors.mjs';
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import {
+  contentInput,
+  createFileCommand,
+  objectInput as sharedObjectInput,
+  relativePathInput,
+  requiredString,
+  resolveFileReference,
+  valueOf,
+  withJavaMethod,
+} from './shared.mjs';
+import { resolveWithinBase } from '../core/files.mjs';
+
+const REQUIRED_CONTEXT = ['gatewayUrl', 'uuid'];
+
+function objectInput(input) {
+  return sharedObjectInput(input);
+}
+
+function sortInput(input) {
+  const value = objectInput(input);
+  if (typeof value.fileCode !== 'string' || !value.fileCode.trim()
+    || !Array.isArray(value.ids) || value.ids.length === 0
+    || value.ids.some((id) => !Number.isSafeInteger(id) || id <= 0)) {
+    throw new CliError('ARGUMENT_INVALID', '排序需要 fileCode 和非空正整数 ids');
+  }
+  return value;
+}
+
+function definition(name, path, idempotent, validate, body, javaMethod) {
+  return withJavaMethod({
+    name, method: 'POST', path, idempotent, multipart: false,
+    requiredContext: REQUIRED_CONTEXT, validate,
+    handler: async ({ client, context, input }) => await client.request({
+      method: 'POST', path, idempotent, body: body(input, context),
+    }),
+  }, javaMethod);
+}
+
+function systemFileCreateInput(input) {
+  const value = objectInput(input);
+  requiredString(valueOf(value, 'file_name', 'fileName'), 'file_name');
+  requiredString(valueOf(value, 'file_path', 'filePath'), 'file_path');
+  const fileCode = valueOf(value, 'file_code', 'fileCode');
+  if (!/^000[1-4]$/u.test(String(fileCode ?? ''))) {
+    throw new CliError('ARGUMENT_INVALID', 'file_code 仅支持 0001、0002、0003、0004');
+  }
+  return value;
+}
+
+function systemSmartImportInput(input) {
+  const value = objectInput(input);
+  const fileCode = valueOf(value, 'file_code', 'fileCode');
+  if (!/^000[1-4]$/u.test(String(fileCode ?? ''))) {
+    throw new CliError('ARGUMENT_INVALID', 'file_code 仅支持 0001、0002、0003、0004');
+  }
+  const names = valueOf(value, 'file_names', 'fileNames');
+  if (names !== undefined && (!Array.isArray(names) || names.some((name) => typeof name !== 'string'))) {
+    throw new CliError('ARGUMENT_INVALID', 'file_names 必须是字符串数组');
+  }
+  return value;
+}
+
+function markdownInput(input) {
+  const value = objectInput(input);
+  relativePathInput(valueOf(value, 'file_name', 'fileName'), 'file_name');
+  normalizeMarkdownFileType(value);
+  return value;
+}
+
+function normalizeMarkdownFileType(input) {
+  const rawType = valueOf(input, 'file_type', 'fileType');
+  if (rawType === undefined) return 'docx';
+  requiredString(rawType, 'file_type');
+  const normalized = rawType.trim().replace(/^\.+/u, '').toLowerCase();
+  if (!['docx', 'pdf'].includes(normalized)) {
+    throw new CliError('ARGUMENT_INVALID', 'file_type 仅支持 docx 或 pdf');
+  }
+  return normalized;
+}
+
+async function importSystemWorkspaceFile({ client, context, baseDir, fileName, fileCode }) {
+  if (typeof baseDir !== 'string' || !baseDir || /^https?:\/\//iu.test(fileName) || fileName.startsWith('/')) {
+    return false;
+  }
+  let resolvedPath;
+  try {
+    resolvedPath = resolveWithinBase(fileName, baseDir);
+  } catch (error) {
+    if (error?.code === 'FILE_OUTSIDE_BASE') return false;
+    throw error;
+  }
+
+  let content;
+  try {
+    content = await readFile(resolvedPath);
+  } catch (error) {
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') return false;
+    throw error;
+  }
+
+  const formData = new FormData();
+  formData.append('uuid', context.uuid);
+  formData.append('fileCode', fileCode);
+  formData.append('file', new Blob([content]), basename(resolvedPath));
+  await client.upload({
+    path: '/api/internal/v1/project-writing/system-manage-file/workspace-import',
+    formData,
+  });
+  return true;
+}
+
+export const commands = [
+  definition(
+    'policy.detail', '/api/project-writing/system-manage-situation/detail', true, objectInput,
+    (_input, context) => ({ uuid: context.uuid }),
+    'project_writing_system_manage_situation_get',
+  ),
+  definition(
+    'policy.save', '/api/project-writing/system-manage-situation/save-or-update', false, objectInput,
+    (input, context) => ({ ...input, uuid: context.uuid }),
+    'project_writing_system_manage_situation_save_or_update',
+  ),
+  definition(
+    'policy.files', '/api/project-writing/system-manage-file/list', true, objectInput,
+    (_input, context) => ({ uuid: context.uuid }),
+  ),
+  definition(
+    'policy.sort-files', '/api/project-writing/system-manage-file/sort', false, sortInput,
+    (input, context) => ({ uuid: context.uuid, fileCode: input.fileCode, ids: input.ids }),
+  ),
+  withJavaMethod({
+    name: 'policy.file-smart-import', method: 'POST', path: '/api/project-writing/system-manage-file/smart-import',
+    idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT,
+    validate: systemSmartImportInput, javaMethod: 'project_writing_system_manage_file_smart_import',
+    handler: async ({ client, context, input, baseDir }) => {
+      const fileCode = valueOf(input, 'file_code', 'fileCode');
+      const names = [...new Set((valueOf(input, 'file_names', 'fileNames') ?? [])
+        .map((name) => name.trim()).filter(Boolean))];
+      const unresolved = [];
+      for (const name of names) {
+        if (!await importSystemWorkspaceFile({ client, context, baseDir, fileName: name, fileCode })) {
+          unresolved.push(name);
+        }
+      }
+      if (unresolved.length === 0 && !input.documentIds?.length) return true;
+      return await client.request({
+        method: 'POST', path: '/api/project-writing/system-manage-file/smart-import', idempotent: false,
+        body: {
+          uuid: context.uuid, fileCode,
+          ...(unresolved.length ? { fileNames: unresolved } : {}),
+          ...(input.documentIds ? { documentIds: input.documentIds } : {}),
+        },
+      });
+    },
+  }, 'project_writing_system_manage_file_smart_import'),
+  withJavaMethod({
+    name: 'policy.file-create', method: 'POST', path: '/api/project-writing/system-manage-file/create',
+    idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT,
+    validate: systemFileCreateInput, javaMethod: 'project_writing_system_manage_file_create',
+    handler: async ({ client, context, input, baseDir }) => {
+      const reference = await resolveFileReference({
+        client, context, baseDir,
+        filePath: valueOf(input, 'file_path', 'filePath'),
+        fileName: valueOf(input, 'file_name', 'fileName'),
+      });
+      return await client.request({
+        method: 'POST', path: '/api/project-writing/system-manage-file/create', idempotent: false,
+        body: {
+          uuid: context.uuid, fileType: '2',
+          fileCode: valueOf(input, 'file_code', 'fileCode'),
+          fileFormat: valueOf(input, 'file_format', 'fileFormat'),
+          ...reference,
+        },
+      });
+    },
+  }, 'project_writing_system_manage_file_create'),
+  withJavaMethod({
+    name: 'policy.file-md-to-docx', method: 'POST', path: '/api/project-writing/system-manage-file/md-to-docx',
+    idempotent: false, multipart: false, requiredContext: REQUIRED_CONTEXT,
+    validate: markdownInput, javaMethod: 'project_writing_system_manage_file_md_to_docx',
+    handler: async ({ client, context, input, baseDir }) => {
+      if (typeof baseDir !== 'string' || !baseDir) {
+        throw new CliError('CONFIG_MISSING', 'Markdown 转换缺少 baseDir');
+      }
+      const relativePath = valueOf(input, 'file_name', 'fileName');
+      const resolvedPath = resolveWithinBase(relativePath, baseDir);
+      let content;
+      try {
+        content = await readFile(resolvedPath);
+      } catch {
+        throw new CliError('FILE_NOT_FOUND', 'Markdown 文件不存在', {
+          relativePath, baseDir, resolvedPath,
+        });
+      }
+      return await client.request({
+        method: 'POST', path: '/api/project-writing/system-manage-file/md-to-docx', idempotent: false,
+        body: {
+          uuid: context.uuid,
+          fileName: basename(resolvedPath),
+          content: content.toString('utf8'),
+          fileType: normalizeMarkdownFileType(input),
+        },
+      });
+    },
+  }, 'project_writing_system_manage_file_md_to_docx'),
+];