@guanwenai/high-tech-project-cli 0.1.0

package/scripts/core/userConfig.mjs

@@ -0,0 +1,100 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+import { CliError } from './errors.mjs';
+
+const CONFIG_FILE_ENVIRONMENT_NAME = 'GUANWEN_PROJECT_WRITING_CONFIG_FILE';
+
+function configuredValue(value) {
+  if (value === undefined || value === null) return '';
+  return String(value).trim();
+}
+
+function validateGatewayUrl(value) {
+  const gatewayUrl = configuredValue(value);
+  let parsed;
+  try {
+    parsed = new URL(gatewayUrl);
+  } catch {
+    throw new CliError('CONFIG_INVALID', 'gateway URL 无效');
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol)
+    || parsed.username
+    || parsed.password
+    || parsed.hash) {
+    throw new CliError('CONFIG_INVALID', 'gateway URL 无效');
+  }
+  return gatewayUrl;
+}
+
+export function resolveUserConfigPath({
+  environment = process.env,
+  platform = process.platform,
+  homeDirectory = homedir(),
+} = {}) {
+  const configuredPath = configuredValue(environment[CONFIG_FILE_ENVIRONMENT_NAME]);
+  if (configuredPath) return resolve(configuredPath);
+
+  if (platform === 'win32') {
+    const appData = configuredValue(environment.APPDATA)
+      || join(homeDirectory, 'AppData', 'Roaming');
+    return join(appData, 'Guanwen', 'high-tech-project', 'config.json');
+  }
+  const configHome = configuredValue(environment.XDG_CONFIG_HOME)
+    || join(homeDirectory, '.config');
+  return join(configHome, 'guanwen', 'high-tech-project', 'config.json');
+}
+
+export async function loadUserConfiguration(options = {}) {
+  const configPath = resolveUserConfigPath(options);
+  let source;
+  try {
+    source = await readFile(configPath, 'utf8');
+  } catch (error) {
+    if (error?.code === 'ENOENT') return {};
+    throw new CliError('CONFIG_INVALID', '无法读取项目申报 CLI 配置', { configPath });
+  }
+
+  let configuration;
+  try {
+    configuration = JSON.parse(source);
+  } catch {
+    throw new CliError('CONFIG_INVALID', '项目申报 CLI 配置文件不是合法 JSON', { configPath });
+  }
+  if (configuration === null || Array.isArray(configuration) || typeof configuration !== 'object') {
+    throw new CliError('CONFIG_INVALID', '项目申报 CLI 配置文件必须是 JSON 对象', { configPath });
+  }
+  if (configuration.gatewayUrl === undefined || configuration.gatewayUrl === null
+    || configuredValue(configuration.gatewayUrl) === '') {
+    return {};
+  }
+  try {
+    return { gatewayUrl: validateGatewayUrl(configuration.gatewayUrl) };
+  } catch (error) {
+    if (error instanceof CliError) error.details = { configPath };
+    throw error;
+  }
+}
+
+export async function persistGatewayUrl(gatewayUrl, options = {}) {
+  const value = validateGatewayUrl(gatewayUrl);
+  const configPath = resolveUserConfigPath(options);
+  const temporaryPath = `${configPath}.${process.pid}.${randomUUID()}.tmp`;
+  await mkdir(dirname(configPath), { recursive: true });
+  try {
+    await writeFile(
+      temporaryPath,
+      `${JSON.stringify({ gatewayUrl: value }, null, 2)}\n`,
+      { encoding: 'utf8', flag: 'wx', mode: 0o600 },
+    );
+    await rename(temporaryPath, configPath);
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw new CliError('FILE_WRITE_FAILED', '无法写入项目申报 CLI 配置', { configPath });
+  } finally {
+    await rm(temporaryPath, { force: true }).catch(() => undefined);
+  }
+  return configPath;
+}

package/scripts/high-tech-project-cli.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { parseArguments } from './cli/arguments.mjs';
+import { CommandRegistry } from './cli/commandRegistry.mjs';
+import { failureEnvelope, serializeEnvelope, successEnvelope } from './cli/output.mjs';
+import { resolveProjectContext } from './core/context.mjs';
+import { CliError, normalizeCliError } from './core/errors.mjs';
+import { readJsonInput } from './core/files.mjs';
+import { GatewayClient } from './core/gatewayClient.mjs';
+import { loadUserConfiguration } from './core/userConfig.mjs';
+import { commands as achievementCommands } from './services/achievement.mjs';
+import { commands as financeCommands } from './services/finance.mjs';
+import { commands as iprCommands } from './services/ipr.mjs';
+import { commands as knowledgeCommands } from './services/knowledge.mjs';
+import { commands as peopleCommands } from './services/people.mjs';
+import { commands as materialCommands } from './services/material.mjs';
+import { commands as policyCommands } from './services/policy.mjs';
+import { commands as productCommands } from './services/product.mjs';
+import { commands as projectCommands } from './services/project.mjs';
+import { commands as rdCommands } from './services/rd.mjs';
+import { commands as reportCommands } from './services/report.mjs';
+import { commands as sopCommands } from './services/sop.mjs';
+import { commands as workflowCommands } from './services/workflow.mjs';
+import { JAVA_PROJECT_WRITING_METHODS } from './methodMappings.mjs';
+import { withJavaMethod } from './services/shared.mjs';
+
+function validateObject(input) {
+  if (input === null || Array.isArray(input) || typeof input !== 'object') {
+    throw new CliError('ARGUMENT_INVALID', '命令输入必须是对象');
+  }
+  return input;
+}
+
+function commandSummary(definition) {
+  return {
+    name: definition.name,
+    javaMethod: definition.javaMethod ?? null,
+    method: definition.method,
+    path: definition.path,
+    idempotent: definition.idempotent,
+    requiredContext: definition.requiredContext,
+  };
+}
+
+function metaDescribeInput(input) {
+  const value = validateObject(input);
+  if (typeof value.method !== 'string' || !value.method.trim()) {
+    throw new CliError('ARGUMENT_INVALID', 'method 不能为空');
+  }
+  return value;
+}
+
+export function createCommandRegistry() {
+  const registry = new CommandRegistry();
+  registry.register({
+    name: 'help',
+    method: 'LOCAL',
+    path: null,
+    idempotent: false,
+    requiredContext: [],
+    validate: validateObject,
+    handler: async () => ({
+      usage: 'high-tech-project <domain> <operation> [options]',
+      discovery: '运行 commands 查看可用命令',
+    }),
+  });
+  registry.register({
+    name: 'commands',
+    method: 'LOCAL',
+    path: null,
+    idempotent: false,
+    requiredContext: [],
+    validate: validateObject,
+    handler: async () => ({ commands: registry.list().map(commandSummary) }),
+  });
+  registry.register({
+    name: 'meta.list',
+    method: 'LOCAL',
+    path: null,
+    idempotent: false,
+    requiredContext: [],
+    validate: validateObject,
+    handler: async ({ registry: currentRegistry }) => ({
+      methods: JAVA_PROJECT_WRITING_METHODS.map((method) => ({
+        method,
+        command: currentRegistry.list().find((item) => item.javaMethod === method)?.name ?? null,
+      })),
+    }),
+  });
+  registry.register({
+    name: 'meta.describe',
+    method: 'LOCAL',
+    path: null,
+    idempotent: false,
+    requiredContext: [],
+    validate: metaDescribeInput,
+    handler: async ({ registry: currentRegistry, input }) => {
+      const definition = currentRegistry.list().find((item) => item.javaMethod === input.method);
+      if (!definition) {
+        throw new CliError('ARGUMENT_INVALID', `未知项目撰写方法: ${input.method}`);
+      }
+      return { method: input.method, command: commandSummary(definition) };
+    },
+  });
+  registry.register({
+    name: 'account.check',
+    method: 'LOCAL',
+    path: null,
+    idempotent: false,
+    requiredContext: [],
+    validate: validateObject,
+    handler: async ({ context }) => ({
+      gatewayUrl: context.gatewayUrl,
+      contextId: context.contextId,
+      tenantCode: context.tenantCode,
+      userId: context.userId,
+      userName: context.userName,
+      realname: context.realname,
+      credentialConfigured: Boolean(context.kfcloudAuth),
+    }),
+  });
+  registry.register({
+    name: 'account.test',
+    method: 'POST',
+    path: '/api/project-writing/bind/list',
+    idempotent: true,
+    requiredContext: ['gatewayUrl'],
+    validate: validateObject,
+    handler: async ({ client, context }) => {
+      await client.request({
+        method: 'POST',
+        path: '/api/project-writing/bind/list',
+        idempotent: true,
+        body: context.tenantCode ? { tenantCode: context.tenantCode } : {},
+      });
+      return { connected: true };
+    },
+  });
+  for (const command of [
+    ...projectCommands,
+    ...peopleCommands,
+    ...iprCommands,
+    ...rdCommands,
+    ...productCommands,
+    ...financeCommands,
+    ...achievementCommands,
+    ...policyCommands,
+    ...materialCommands,
+    ...reportCommands,
+    ...sopCommands,
+    ...knowledgeCommands,
+    ...workflowCommands,
+  ]) {
+    registry.register(command.javaMethod ? withJavaMethod(command, command.javaMethod) : command);
+  }
+  const mappedMethods = new Set(registry.list().map((definition) => definition.javaMethod).filter(Boolean));
+  const missingMethods = JAVA_PROJECT_WRITING_METHODS.filter((method) => !mappedMethods.has(method));
+  if (missingMethods.length > 0) {
+    throw new CliError('CLI_INTERNAL_ERROR', '项目撰写方法未完成 CLI 映射', { missingMethods });
+  }
+  return registry;
+}
+
+function requestedCommand(argv) {
+  return argv.filter((token) => !token.startsWith('--')).slice(0, 2).join('.') || 'unknown';
+}
+
+function hasInvocationGateway(options, input, environment) {
+  return [
+    options.gatewayUrl,
+    input.gatewayUrl,
+    environment.GUANWEN_PROJECT_WRITING_GATEWAY_URL,
+  ].some((value) => value !== undefined && value !== null && String(value).trim() !== '');
+}
+
+function assertRequiredContext(definition, context) {
+  const missing = definition.requiredContext.filter((field) => !context[field]);
+  if (missing.length > 0) {
+    throw new CliError('CONFIG_MISSING', '项目申报账户配置不完整', { missing });
+  }
+}
+
+function diagnosticLogger(stream) {
+  return {
+    warn(entry) {
+      stream.write(`${JSON.stringify(entry)}\n`);
+    },
+  };
+}
+
+export async function executeCli(
+  argv,
+  {
+    environment = process.env,
+    cwd = process.cwd(),
+    registry = createCommandRegistry(),
+    requestId = randomUUID(),
+    clock = () => performance.now(),
+    stderr = process.stderr,
+  } = {},
+) {
+  const startedAt = clock();
+  let command = requestedCommand(argv);
+  let pretty = argv.includes('--pretty');
+  try {
+    const parsed = parseArguments(argv);
+    command = parsed.command;
+    pretty = parsed.options.pretty === true;
+    const definition = registry.get(command);
+    if (!definition) {
+      throw new CliError('ARGUMENT_INVALID', `未知命令: ${command}`);
+    }
+    const input = parsed.options.input
+      ? await readJsonInput(parsed.options.input, parsed.options.baseDir || cwd)
+      : {};
+    const configuration = hasInvocationGateway(parsed.options, input, environment)
+      ? {}
+      : await loadUserConfiguration({ environment });
+    const context = resolveProjectContext({
+      options: parsed.options,
+      input,
+      environment,
+      configuration,
+    });
+    assertRequiredContext(definition, context);
+    const validatedInput = definition.validate(input);
+    const client = definition.method === 'LOCAL'
+      ? null
+      : new GatewayClient({ context, logger: diagnosticLogger(stderr) });
+    const data = await definition.handler({
+      client,
+      command: definition,
+      context,
+      input: validatedInput,
+      registry,
+      baseDir: parsed.options.baseDir || cwd,
+    });
+    return {
+      envelope: successEnvelope(command, data, {
+        requestId,
+        durationMs: Math.max(0, Math.round(clock() - startedAt)),
+      }),
+      exitCode: 0,
+      pretty,
+    };
+  } catch (error) {
+    const normalized = normalizeCliError(error);
+    return {
+      envelope: failureEnvelope(command, normalized, {
+        requestId,
+        durationMs: Math.max(0, Math.round(clock() - startedAt)),
+      }),
+      exitCode: normalized.exitCode,
+      pretty,
+    };
+  }
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const result = await executeCli(argv);
+  process.stdout.write(`${serializeEnvelope(result.envelope, result.pretty)}\n`);
+  process.exitCode = result.exitCode;
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : '';
+if (invokedPath === import.meta.url) {
+  await main();
+}

package/scripts/install/configure-gateway.mjs

@@ -0,0 +1,39 @@
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { persistGatewayUrl } from '../core/userConfig.mjs';
+
+function installGateway(environment) {
+  return String(
+    environment.npm_config_guanwen_gateway_url
+      || environment.GUANWEN_PROJECT_WRITING_INSTALL_GATEWAY_URL
+      || '',
+  ).trim();
+}
+
+export async function configureGatewayFromInstall({
+  environment = process.env,
+  stdout = process.stdout,
+} = {}) {
+  const gatewayUrl = installGateway(environment);
+  if (!gatewayUrl) return { configured: false };
+
+  const configPath = await persistGatewayUrl(gatewayUrl, { environment });
+  stdout.write(`[high-tech-project] gateway configured in ${configPath}\n`);
+  return { configured: true, configPath };
+}
+
+export async function main() {
+  try {
+    await configureGatewayFromInstall();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'gateway 配置失败';
+    process.stderr.write(`[high-tech-project] ${message}\n`);
+    process.exitCode = 1;
+  }
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : '';
+if (invokedPath === import.meta.url) {
+  await main();
+}

package/scripts/methodMappings.mjs

@@ -0,0 +1,29 @@
+export const JAVA_PROJECT_WRITING_METHODS = Object.freeze([
+  'project_writing_customer_detail',
+  'project_writing_person_list', 'project_writing_person_batch_save_all', 'project_writing_person_batch_save',
+  'project_writing_person_chart_stats', 'project_writing_person_situation_get', 'project_writing_person_situation_batch_save',
+  'project_writing_person_file_create', 'project_writing_person_file_smart_import', 'project_writing_person_batch_delete_by_uuid',
+  'project_writing_ipr_list', 'project_writing_ipr_batch_save', 'project_writing_ipr_batch_delete_by_uuid',
+  'project_writing_ipr_file_create', 'project_writing_ipr_file_smart_import',
+  'project_writing_system_manage_file_smart_import', 'project_writing_system_manage_file_create',
+  'project_writing_system_manage_file_md_to_docx', 'project_writing_supplement_file_list',
+  'project_writing_supplement_file_update', 'project_writing_ipr_situation_get', 'project_writing_ipr_situation_batch_save',
+  'project_writing_rd_project_list', 'project_writing_rd_project_batch_save', 'project_writing_rd_project_bind_iprs',
+  'project_writing_rd_project_bind_person', 'project_writing_rd_project_bind_fee', 'project_writing_rd_project_batch_delete',
+  'project_writing_rd_project_file_list', 'project_writing_rd_project_file_create', 'project_writing_rd_project_file_delete_batch',
+  'project_writing_ps_product_list', 'project_writing_ps_product_batch_save', 'project_writing_ps_product_bind_iprs',
+  'project_writing_ps_product_bind_rd_projects', 'project_writing_ps_product_batch_delete',
+  'project_writing_ps_product_file_list', 'project_writing_ps_product_file_create', 'project_writing_ps_product_file_delete_batch',
+  'project_writing_tech_achievement_situation_get', 'project_writing_tech_achievement_situation_save_or_update',
+  'project_writing_system_manage_situation_get', 'project_writing_system_manage_situation_save_or_update',
+  'project_writing_tech_achievement_create', 'project_writing_tech_achievement_update',
+  'project_writing_tech_achievement_list', 'project_writing_tech_achievement_file_create',
+  'project_writing_rd_project_brief_create', 'project_writing_rd_project_brief_update', 'project_writing_rd_project_brief_detail',
+  'project_writing_ps_product_brief_create', 'project_writing_ps_product_brief_update', 'project_writing_ps_product_brief_detail',
+  'project_writing_fee_detail_create', 'project_writing_fee_detail_update', 'project_writing_fee_detail_list',
+  'project_writing_fee_detail_batch_save', 'project_writing_operation_status_create',
+  'project_writing_operation_status_update', 'project_writing_operation_status_list', 'project_writing_operation_status_batch_save',
+  'project_writing_product_income_create', 'project_writing_product_income_update',
+  'project_writing_product_income_list', 'project_writing_product_income_batch_save',
+  'project_writing_rd_fund_situation_list', 'project_writing_rd_fund_situation_batch_save',
+]);

package/scripts/services/achievement.mjs

@@ -0,0 +1,147 @@
+import { CliError } from '../core/errors.mjs';
+import {
+  contentInput,
+  createFileCommand,
+  objectInput as sharedObjectInput,
+  requiredString,
+  valueOf,
+  withJavaMethod,
+} from './shared.mjs';
+
+const REQUIRED_CONTEXT = ['gatewayUrl', 'uuid'];
+
+function objectInput(input) {
+  return sharedObjectInput(input);
+}
+
+function positiveId(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new CliError('ARGUMENT_INVALID', `${field} 必须是正整数`);
+  }
+}
+
+function pageInput(input) {
+  const value = objectInput(input);
+  for (const field of ['pageNumber', 'pageSize']) {
+    if (value[field] !== undefined) positiveId(value[field], field);
+  }
+  return value;
+}
+
+function idsInput(input) {
+  const value = objectInput(input);
+  if (!Array.isArray(value.ids) || value.ids.length === 0) {
+    throw new CliError('ARGUMENT_INVALID', 'ids 必须是非空 ID 数组');
+  }
+  value.ids.forEach((id) => positiveId(id, 'ids'));
+  return value;
+}
+
+function achievementInput(input) {
+  const value = objectInput(input);
+  positiveId(value.techAchievementId, 'techAchievementId');
+  return value;
+}
+
+function definition(name, path, idempotent, validate, handler, javaMethod) {
+  return withJavaMethod({ name, method: 'POST', path, idempotent, multipart: false, requiredContext: REQUIRED_CONTEXT, validate, handler }, javaMethod);
+}
+
+function fileCreateInput(input) {
+  const value = objectInput(input);
+  if (!Number.isSafeInteger(value.techAchievementId ?? value.tech_achievement_id)
+    || (value.techAchievementId ?? value.tech_achievement_id) <= 0) {
+    throw new CliError('ARGUMENT_INVALID', 'tech_achievement_id 必须是正整数');
+  }
+  requiredString(value.fileName ?? value.file_name, 'file_name');
+  requiredString(value.filePath ?? value.file_path, 'file_path');
+  return value;
+}
+
+export const commands = [
+  definition(
+    'achievement.list', '/api/project-writing/tech-achievement/page', true, pageInput,
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement/page', idempotent: true,
+      body: { ...input, pageNumber: input.pageNumber ?? 1, pageSize: input.pageSize ?? 20, uuid: context.uuid },
+    }),
+  ),
+  definition(
+    'achievement.save', '/api/project-writing/tech-achievement/create', false, objectInput,
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', idempotent: false,
+      path: input.id
+        ? '/api/project-writing/tech-achievement/update'
+        : '/api/project-writing/tech-achievement/create',
+      body: { ...input, uuid: context.uuid },
+    }),
+  ),
+  definition(
+    'achievement.situation-get', '/api/project-writing/tech-achievement-situation/detail', true, objectInput,
+    async ({ client, context }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement-situation/detail', idempotent: true,
+      body: { uuid: context.uuid },
+    }), 'project_writing_tech_achievement_situation_get',
+  ),
+  definition(
+    'achievement.situation-save', '/api/project-writing/tech-achievement-situation/save-or-update', false, contentInput,
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement-situation/save-or-update', idempotent: false,
+      body: { uuid: context.uuid, content: valueOf(input, 'content') },
+    }), 'project_writing_tech_achievement_situation_save_or_update',
+  ),
+  definition(
+    'achievement.create', '/api/project-writing/tech-achievement/create', false, objectInput,
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement/create', idempotent: false,
+      body: { ...input, uuid: context.uuid },
+    }), 'project_writing_tech_achievement_create',
+  ),
+  definition(
+    'achievement.update', '/api/project-writing/tech-achievement/update', false, (input) => {
+      const value = objectInput(input);
+      positiveId(value.id, 'id');
+      return value;
+    },
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement/update', idempotent: false,
+      body: { ...input, uuid: context.uuid },
+    }), 'project_writing_tech_achievement_update',
+  ),
+  definition(
+    'achievement.list-all', '/api/project-writing/tech-achievement/list', true, objectInput,
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement/list', idempotent: true,
+      body: { ...input, uuid: context.uuid },
+    }), 'project_writing_tech_achievement_list',
+  ),
+  withJavaMethod(createFileCommand({
+    name: 'achievement.file-create', path: '/api/project-writing/tech-achievement-file/create',
+    idField: 'techAchievementId', validate: fileCreateInput,
+    extraFields: [
+      { snake: 'file_type', camel: 'fileType' },
+      { snake: 'file_code', camel: 'fileCode' },
+      { snake: 'file_format', camel: 'fileFormat' },
+    ],
+  }), 'project_writing_tech_achievement_file_create'),
+  definition(
+    'achievement.delete-batch', '/api/project-writing/tech-achievement/delete-batch', false, idsInput,
+    async ({ client, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement/delete-batch', body: input.ids, idempotent: false,
+    }),
+  ),
+  definition(
+    'achievement.files', '/api/project-writing/tech-achievement-file/list', true, achievementInput,
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement-file/list', idempotent: true,
+      body: { uuid: context.uuid, techAchievementId: input.techAchievementId },
+    }),
+  ),
+  definition(
+    'achievement.submissions', '/api/project-writing/tech-achievement-submit/list', true, achievementInput,
+    async ({ client, context, input }) => await client.request({
+      method: 'POST', path: '/api/project-writing/tech-achievement-submit/list', idempotent: true,
+      body: { uuid: context.uuid, techAchievementId: input.techAchievementId },
+    }),
+  ),
+];