@hecom/codearts 0.2.0 → 0.2.2

package/dist/commands/work-hour.command.js

@@ -4,150 +4,208 @@ exports.workHourCommand = workHourCommand;
 const holidays_1 = require("../config/holidays");
 const business_service_1 = require("../services/business.service");
 const config_loader_1 = require("../utils/config-loader");
+const csv_writer_1 = require("../utils/csv-writer");
+const logger_1 = require("../utils/logger");
 /**
- * work-hour 命令入口
+ * 处理浮点数精度，保留2位小数
  */
-async function workHourCommand(year, cliOptions = {}) {
-    try {
-        const targetYear = year || new Date().getFullYear().toString();
-        console.log(`开始获取 ${targetYear} 年工时统计...`);
-        const { projectId, roleIds, config } = (0, config_loader_1.loadConfig)(cliOptions);
-        const businessService = new business_service_1.BusinessService(config);
-        // 收集所有角色的成员和工时数据
-        const allMembers = [];
-        const allUserStats = [];
-        const allTypes = new Set();
-        for (const roleId of roleIds) {
-            const roleMembers = await businessService.getMembersByRoleId(projectId, roleId);
-            if (roleMembers.length === 0) {
-                console.log(`角色ID ${roleId} 未找到用户，跳过`);
-                continue;
-            }
-            const roleName = roleMembers[0].role_name;
-            allMembers.push(...roleMembers);
-            const roleUserIds = roleMembers.map((member) => member.user_id);
-            const stats = await businessService.getAllWorkHourStats(projectId, roleUserIds, `${targetYear}-01-01`, `${targetYear}-12-31`);
-            // 为每个用户添加角色信息
-            stats.userStats.forEach((userStat) => {
-                allUserStats.push({
-                    ...userStat,
-                    roleName,
-                    roleId,
-                });
-                // 收集所有领域类型
-                userStat.domainStats.forEach((domainStat) => {
-                    allTypes.add(domainStat.type);
-                });
+function roundToTwo(num) {
+    return Math.round(num * 100) / 100;
+}
+/**
+ * 查询年度工时数据
+ */
+async function queryWorkHourReportData(businessService, projectId, roleIds, targetYear) {
+    const allMembers = [];
+    const allUserStats = [];
+    const allTypes = new Set();
+    for (const roleId of roleIds) {
+        const roleMembers = await businessService.getMembersByRoleId(projectId, roleId);
+        if (roleMembers.length === 0) {
+            logger_1.logger.warn(`角色ID ${roleId} 未找到用户，跳过`);
+            continue;
+        }
+        const roleName = roleMembers[0].role_name;
+        allMembers.push(...roleMembers);
+        const roleUserIds = roleMembers.map((member) => member.user_id);
+        const stats = await businessService.getAllWorkHourStats(projectId, roleUserIds, `${targetYear}-01-01`, `${targetYear}-12-31`);
+        stats.userStats.forEach((userStat) => {
+            allUserStats.push({
+                ...userStat,
+                roleName,
+                roleId,
+            });
+            userStat.domainStats.forEach((domainStat) => {
+                allTypes.add(domainStat.type);
             });
+        });
+    }
+    allUserStats.sort((a, b) => {
+        if (a.roleId !== b.roleId) {
+            return a.roleId - b.roleId;
         }
-        if (allMembers.length === 0) {
-            console.log('未找到任何角色的用户');
-            return;
+        return a.userName.localeCompare(b.userName);
+    });
+    const expectedWorkdays = (0, holidays_1.calculateExpectedWorkdays)(targetYear);
+    const expectedHoursPerPerson = expectedWorkdays * 8;
+    const totalExpectedHours = expectedHoursPerPerson * allMembers.length;
+    const totalHours = roundToTwo(allUserStats.reduce((sum, userStat) => sum + userStat.totalHours, 0));
+    const totalEntries = allUserStats.reduce((sum, userStat) => sum + userStat.domainStats.reduce((s, d) => s + d.workHours.length, 0), 0);
+    const userStatsData = [];
+    const roleSubtotals = [];
+    const typeTotals = {};
+    allTypes.forEach((type) => {
+        typeTotals[type] = 0;
+    });
+    let currentRoleId = null;
+    let currentRoleName = '';
+    const roleSubtotalStats = {};
+    allUserStats.forEach((userStat, index) => {
+        if (currentRoleId !== null && currentRoleId !== userStat.roleId) {
+            const subtotalDomainStats = {};
+            let subtotal = 0;
+            allTypes.forEach((type) => {
+                subtotalDomainStats[type] = roleSubtotalStats[type] || 0;
+                subtotal = roundToTwo(subtotal + (roleSubtotalStats[type] || 0));
+            });
+            roleSubtotals.push({
+                roleName: currentRoleName,
+                domainStats: subtotalDomainStats,
+                total: subtotal,
+            });
+            Object.keys(roleSubtotalStats).forEach((key) => {
+                roleSubtotalStats[key] = 0;
+            });
         }
-        // 按角色ID排序用户
-        allUserStats.sort((a, b) => {
-            if (a.roleId !== b.roleId) {
-                return a.roleId - b.roleId;
-            }
-            return a.userName.localeCompare(b.userName);
-        });
-        const expectedWorkdays = (0, holidays_1.calculateExpectedWorkdays)(targetYear);
-        const expectedHoursPerPerson = expectedWorkdays * 8;
-        const totalExpectedHours = expectedHoursPerPerson * allMembers.length;
-        // 计算总工时
-        const totalHours = allUserStats.reduce((sum, userStat) => sum + userStat.totalHours, 0);
-        const totalEntries = allUserStats.reduce((sum, userStat) => sum + userStat.domainStats.reduce((s, d) => s + d.workHours.length, 0), 0);
-        console.log(`\n${targetYear}年工时统计报告`);
-        console.log('='.repeat(80));
-        console.log(`统计期间: ${targetYear}-01-01 至 ${targetYear}-12-31`);
-        console.log(`统计角色: ${roleIds.length} 个角色`);
-        console.log(`统计人数: ${allMembers.length} 人`);
-        console.log(`应计工作日: ${expectedWorkdays} 天`);
-        console.log(`应计工时: ${totalExpectedHours} 小时 (${expectedHoursPerPerson} 小时/人)`);
-        console.log(`实际工时: ${totalHours} 小时`);
-        console.log(`工时完成率: ${((totalHours / totalExpectedHours) * 100).toFixed(2)}%`);
-        console.log(`工时条目: ${totalEntries} 条`);
-        console.log('='.repeat(80));
-        // 构建表格数据：人作为行，type作为列
-        const tableData = {};
-        const typeTotals = {};
-        // 初始化总计
+        currentRoleId = userStat.roleId;
+        currentRoleName = userStat.roleName;
+        const domainStats = {};
         allTypes.forEach((type) => {
-            typeTotals[type] = 0;
+            domainStats[type] = 0;
         });
-        // 按角色分组并填充数据
-        let currentRoleId = null;
-        let currentRoleName = '';
-        const roleSubtotals = {};
-        allUserStats.forEach((userStat, index) => {
-            // 检测角色变化，插入小计行
-            if (currentRoleId !== null && currentRoleId !== userStat.roleId) {
-                const subtotalRow = {};
-                subtotalRow['角色'] = `${currentRoleName} 小计`;
-                let subtotal = 0;
-                allTypes.forEach((type) => {
-                    subtotalRow[type] = roleSubtotals[type] || 0;
-                    subtotal += roleSubtotals[type] || 0;
-                });
-                subtotalRow['合计'] = subtotal;
-                tableData[`─ ${currentRoleName} 小计`] = subtotalRow;
-                // 重置小计
-                Object.keys(roleSubtotals).forEach((key) => {
-                    roleSubtotals[key] = 0;
-                });
+        let userTotal = 0;
+        userStat.domainStats.forEach((domainStat) => {
+            domainStats[domainStat.type] = domainStat.totalHours;
+            userTotal = roundToTwo(userTotal + domainStat.totalHours);
+            typeTotals[domainStat.type] = roundToTwo(typeTotals[domainStat.type] + domainStat.totalHours);
+            if (!roleSubtotalStats[domainStat.type]) {
+                roleSubtotalStats[domainStat.type] = 0;
             }
-            // 更新当前角色
-            currentRoleId = userStat.roleId;
-            currentRoleName = userStat.roleName;
-            // 填充用户数据
-            const row = {};
-            row['角色'] = userStat.roleName;
-            // 初始化所有类型为0
+            roleSubtotalStats[domainStat.type] = roundToTwo(roleSubtotalStats[domainStat.type] + domainStat.totalHours);
+        });
+        userStatsData.push({
+            userName: userStat.userName,
+            roleName: userStat.roleName,
+            roleId: userStat.roleId,
+            domainStats,
+            total: userTotal,
+        });
+        if (index === allUserStats.length - 1) {
+            const subtotalDomainStats = {};
+            let subtotal = 0;
             allTypes.forEach((type) => {
-                row[type] = 0;
+                subtotalDomainStats[type] = roleSubtotalStats[type] || 0;
+                subtotal = roundToTwo(subtotal + (roleSubtotalStats[type] || 0));
             });
-            // 填充实际工时
-            let userTotal = 0;
-            userStat.domainStats.forEach((domainStat) => {
-                row[domainStat.type] = domainStat.totalHours;
-                userTotal += domainStat.totalHours;
-                typeTotals[domainStat.type] += domainStat.totalHours;
-                // 累加到角色小计
-                if (!roleSubtotals[domainStat.type]) {
-                    roleSubtotals[domainStat.type] = 0;
-                }
-                roleSubtotals[domainStat.type] += domainStat.totalHours;
+            roleSubtotals.push({
+                roleName: currentRoleName,
+                domainStats: subtotalDomainStats,
+                total: subtotal,
             });
-            row['合计'] = userTotal;
-            tableData[userStat.userName] = row;
-            // 如果是最后一个用户，添加最后一个角色的小计
-            if (index === allUserStats.length - 1) {
-                const subtotalRow = {};
-                subtotalRow['角色'] = `${currentRoleName} 小计`;
-                let subtotal = 0;
-                allTypes.forEach((type) => {
-                    subtotalRow[type] = roleSubtotals[type] || 0;
-                    subtotal += roleSubtotals[type] || 0;
-                });
-                subtotalRow['合计'] = subtotal;
-                tableData[`─ ${currentRoleName} 小计`] = subtotalRow;
-            }
-        });
-        // 添加总计行
-        const totalRow = {};
-        totalRow['角色'] = '━ 总计';
-        let grandTotal = 0;
-        allTypes.forEach((type) => {
-            totalRow[type] = typeTotals[type];
-            grandTotal += typeTotals[type];
-        });
-        totalRow['合计'] = grandTotal;
-        tableData['━━ 总计'] = totalRow;
-        console.log('\n工时统计表:');
-        console.table(tableData);
+        }
+    });
+    const grandTotalDomainStats = {};
+    let grandTotal = 0;
+    allTypes.forEach((type) => {
+        grandTotalDomainStats[type] = typeTotals[type];
+        grandTotal = roundToTwo(grandTotal + typeTotals[type]);
+    });
+    return {
+        year: targetYear,
+        roleCount: roleIds.length,
+        memberCount: allMembers.length,
+        expectedWorkdays,
+        expectedHours: totalExpectedHours,
+        actualHours: totalHours,
+        completionRate: (totalHours / totalExpectedHours) * 100,
+        entryCount: totalEntries,
+        userStats: userStatsData,
+        roleSubtotals,
+        grandTotal: {
+            domainStats: grandTotalDomainStats,
+            total: grandTotal,
+        },
+    };
+}
+/**
+ * 控制台输出工时统计
+ */
+function outputConsole(data) {
+    logger_1.logger.info(`\n${data.year}年工时统计 [${data.roleSubtotals.map((r) => r.roleName).join(', ')}]`);
+    logger_1.logger.info('='.repeat(80));
+    logger_1.logger.info(`统计人数: ${data.memberCount} 人`);
+    logger_1.logger.info(`应计工作日: ${data.expectedWorkdays} 天`);
+    logger_1.logger.info(`应计工时: ${data.expectedHours} 小时`);
+    logger_1.logger.info(`实际工时: ${data.actualHours} 小时`);
+    logger_1.logger.info(`工时完成率: ${data.completionRate.toFixed(2)}%`);
+    logger_1.logger.info('='.repeat(80));
+    // 构建表格数据
+    const tableData = {};
+    data.userStats.forEach((userStat) => {
+        const row = {
+            ...userStat.domainStats,
+            合计: userStat.total,
+        };
+        tableData[userStat.userName] = row;
+    });
+    // 添加总计行
+    tableData['总计'] = {
+        ...data.grandTotal.domainStats,
+        合计: data.grandTotal.total,
+    };
+    logger_1.logger.table(tableData);
+}
+/**
+ * CSV 文件输出
+ */
+function outputCsv(data, targetYear) {
+    const domains = Object.keys(data.grandTotal.domainStats);
+    const csvLines = [];
+    csvLines.push(`用户,角色,${domains.join(',')},合计`);
+    data.userStats.forEach((userStat) => {
+        const domainValues = domains.map((domain) => userStat.domainStats[domain] || 0);
+        csvLines.push(`${userStat.userName},${userStat.roleName},${domainValues.join(',')},${userStat.total}`);
+    });
+    const filename = `work-hour-${targetYear}.csv`;
+    (0, csv_writer_1.writeCsvFile)(filename, csvLines, logger_1.logger);
+}
+/**
+ * JSON 输出（直接打印到控制台，供编程调用）
+ */
+function outputJson(data) {
+    logger_1.logger.json(data);
+}
+/**
+ * work-hour 命令入口
+ */
+async function workHourCommand(year, cliOptions = {}) {
+    try {
+        const targetYear = year || new Date().getFullYear().toString();
+        const { projectId, roleIds, config, outputFormat } = (0, config_loader_1.loadConfig)(cliOptions);
+        const businessService = new business_service_1.BusinessService(config);
+        const reportData = await queryWorkHourReportData(businessService, projectId, roleIds, targetYear);
+        if (outputFormat === 'console') {
+            outputConsole(reportData);
+        }
+        else if (outputFormat === 'csv') {
+            outputCsv(reportData, targetYear);
+        }
+        else if (outputFormat === 'json') {
+            outputJson(reportData);
+        }
     }
     catch (error) {
-        console.error('执行过程中发生错误:', error);
+        logger_1.logger.error(`执行过程中发生错误:`, error);
         process.exit(1);
     }
 }

package/dist/services/api.service.d.ts

@@ -1,4 +1,4 @@
-import { ApiResponse, CachedToken, HuaweiCloudConfig, ListChildIssuesV2Response, ListIssuesV4Request, ListIssuesV4Response, ListProjectIterationsV4Request, ListProjectIterationsV4Response, ProjectListResponse, ProjectMemberListResponse, ProjectMemberQueryParams, ProjectQueryParams, ShowProjectWorkHoursRequest, ShowProjectWorkHoursResponse } from '../types';
+import { ApiResponse, CachedToken, HuaweiCloudConfig, ListChildIssuesV2Response, ListChildIssuesV4Response, ListIssuesV4Request, ListIssuesV4Response, ListProjectIterationsV4Request, ListProjectIterationsV4Response, ProjectListResponse, ProjectMemberListResponse, ProjectMemberQueryParams, ProjectQueryParams, ShowProjectWorkHoursRequest, ShowProjectWorkHoursResponse } from '../types';
 /**
  * 华为云CodeArts API服务类
  * 支持IAM Token认证和CodeArts API调用
@@ -58,8 +58,15 @@ export declare class ApiService {
     /**
      * 查询子工作项 (ListChildIssuesV4)
      * 获取指定工作项的所有子工作项
+     *
+     * FIXME: 华为云接口有问题，只能查询 15 条数据
      */
-    getChildIssues(projectId: string, issueId: string, pageSize?: number, pageNo?: number): Promise<ApiResponse<ListChildIssuesV2Response>>;
+    getChildIssues(projectId: string, issueId: string): Promise<ApiResponse<ListChildIssuesV4Response>>;
+    /**
+     * 查询子工作项 (ListChildIssuesV2)
+     * 获取指定工作项的所有子工作项
+     */
+    getChildIssuesV2(projectId: string, issueId: string, pageSize?: number, pageNo?: number): Promise<ApiResponse<ListChildIssuesV2Response>>;
     /**
      * 创建工作项
      */

package/dist/services/api.service.js

@@ -313,11 +313,19 @@ class ApiService {
     /**
      * 查询子工作项 (ListChildIssuesV4)
      * 获取指定工作项的所有子工作项
+     *
+     * FIXME: 华为云接口有问题，只能查询 15 条数据
      */
-    async getChildIssues(projectId, issueId, pageSize = 100, pageNo = 1) {
-        // return this.request(`/v4/projects/${projectId}/issues/${issueId}/child`, {
-        //   method: 'GET',
-        // });
+    async getChildIssues(projectId, issueId) {
+        return this.request(`/v4/projects/${projectId}/issues/${issueId}/child`, {
+            method: 'GET',
+        });
+    }
+    /**
+     * 查询子工作项 (ListChildIssuesV2)
+     * 获取指定工作项的所有子工作项
+     */
+    async getChildIssuesV2(projectId, issueId, pageSize = 100, pageNo = 1) {
         return this.request('/v2/issues/child-issue-list', {
             method: 'POST',
             data: {

package/dist/services/business.service.d.ts

@@ -1,4 +1,4 @@
-import { AllWorkHourStats, HuaweiCloudConfig, IssueItem, IssueItemV2, IterationInfo, ProjectMember, WorkHourStats, WorkProgressStats } from '../types';
+import { AllWorkHourStats, HuaweiCloudConfig, IssueItem, IssueItemV2, IterationInfo, ProjectMember, ProjectRole, WorkHourStats, WorkProgressStats } from '../types';
 import { ApiService } from './api.service';
 /**
  * 业务服务类
@@ -19,6 +19,12 @@ export declare class BusinessService {
      * @returns 指定角色的成员列表
      */
     getMembersByRoleId(projectId: string, roleId: number): Promise<ProjectMember[]>;
+    /**
+     * 获取项目中的所有角色列表（去重）
+     * @param projectId 项目ID
+     * @returns 项目中的所有角色列表
+     */
+    getProjectRoles(projectId: string): Promise<ProjectRole[]>;
     /**
      * 获取指定日期之后的迭代列表
      * @param projectId 项目ID
@@ -86,4 +92,18 @@ export declare class BusinessService {
      * @returns 所有子工作项列表
      */
     getChildIssues(projectId: string, issueId: string): Promise<IssueItemV2[]>;
+    /**
+     * 验证 IAM 凭证是否有效
+     * @returns 验证结果，包含成功状态和可能的错误信息
+     */
+    validateCredentials(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * 获取项目列表
+     * @param limit 返回的项目数量限制，默认100
+     * @returns 项目列表
+     */
+    getProjects(limit?: number): Promise<import('../types').Project[]>;
 }

package/dist/services/business.service.js

@@ -32,6 +32,45 @@ class BusinessService {
         const allMembers = membersResponse.data?.members || [];
         return allMembers.filter((member) => member.role_id === roleId);
     }
+    /**
+     * 获取项目中的所有角色列表（去重）
+     * @param projectId 项目ID
+     * @returns 项目中的所有角色列表
+     */
+    async getProjectRoles(projectId) {
+        // 分页获取所有成员
+        const allMembers = [];
+        const pageSize = 100;
+        let offset = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const membersResponse = await this.apiService.getMembers(projectId, {
+                limit: pageSize,
+                offset: offset,
+            });
+            if (!membersResponse.success) {
+                throw new Error(`获取成员列表失败: ${membersResponse.error || '未知错误'}`);
+            }
+            const members = membersResponse.data?.members.filter((member) => member.role_id !== -1 && member.nick_name != null) || [];
+            allMembers.push(...members);
+            // 判断是否还有更多数据
+            const total = membersResponse.data?.total || 0;
+            offset += pageSize;
+            hasMore = offset < total;
+        }
+        // 使用 Map 去重，key 为 role_id
+        const rolesMap = new Map();
+        allMembers.forEach((member) => {
+            if (!rolesMap.has(member.role_id)) {
+                rolesMap.set(member.role_id, {
+                    role_id: member.role_id,
+                    role_name: member.role_name,
+                });
+            }
+        });
+        // 转换为数组并按 role_id 排序
+        return Array.from(rolesMap.values()).sort((a, b) => a.role_id - b.role_id);
+    }
     /**
      * 获取指定日期之后的迭代列表
      * @param projectId 项目ID
@@ -383,7 +422,7 @@ class BusinessService {
         let pageNo = 1;
         let hasMore = true;
         while (hasMore) {
-            const response = await this.apiService.getChildIssues(projectId, issueId, pageSize, pageNo);
+            const response = await this.apiService.getChildIssuesV2(projectId, issueId, pageSize, pageNo);
             if (!response.success || !response.data) {
                 throw new Error(`获取子工作项失败: ${response.error || '未知错误'}`);
             }
@@ -395,5 +434,31 @@ class BusinessService {
         }
         return allChildIssues;
     }
+    /**
+     * 验证 IAM 凭证是否有效
+     * @returns 验证结果，包含成功状态和可能的错误信息
+     */
+    async validateCredentials() {
+        try {
+            await this.apiService.refreshToken();
+            return { success: true };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: errorMsg };
+        }
+    }
+    /**
+     * 获取项目列表
+     * @param limit 返回的项目数量限制，默认100
+     * @returns 项目列表
+     */
+    async getProjects(limit = 100) {
+        const response = await this.apiService.getProjects({ limit });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || '获取项目列表失败');
+        }
+        return response.data.projects;
+    }
 }
 exports.BusinessService = BusinessService;

package/dist/types/index.d.ts

@@ -152,6 +152,10 @@ export interface ProjectMemberQueryParams {
     offset?: number;
     limit?: number;
 }
+export interface ProjectRole {
+    role_id: number;
+    role_name: string;
+}
 export interface ShowProjectWorkHoursRequest {
     begin_time?: string;
     end_time?: string;
@@ -521,3 +525,46 @@ export interface AllWorkHourStats {
     totalEntries: number;
     userStats: UserAllWorkHourStats[];
 }
+/**
+ * 配置键枚举
+ * 用于类型安全的配置项访问
+ */
+export declare enum ConfigKey {
+    HUAWEI_CLOUD_IAM_ENDPOINT = "HUAWEI_CLOUD_IAM_ENDPOINT",
+    HUAWEI_CLOUD_REGION = "HUAWEI_CLOUD_REGION",
+    HUAWEI_CLOUD_USERNAME = "HUAWEI_CLOUD_USERNAME",
+    HUAWEI_CLOUD_PASSWORD = "HUAWEI_CLOUD_PASSWORD",
+    HUAWEI_CLOUD_DOMAIN = "HUAWEI_CLOUD_DOMAIN",
+    CODEARTS_BASE_URL = "CODEARTS_BASE_URL",
+    PROJECT_ID = "PROJECT_ID",
+    ROLE_ID = "ROLE_ID"
+}
+/**
+ * 不可变配置键（只能通过 config 命令设置）
+ */
+export declare const IMMUTABLE_CONFIG_KEYS: ConfigKey[];
+/**
+ * 可变配置键（可以通过命令行参数覆盖）
+ */
+export declare const MUTABLE_CONFIG_KEYS: ConfigKey[];
+/**
+ * 类型安全的配置映射
+ */
+export type ConfigMap = {
+    [ConfigKey.HUAWEI_CLOUD_IAM_ENDPOINT]: string;
+    [ConfigKey.HUAWEI_CLOUD_REGION]: string;
+    [ConfigKey.HUAWEI_CLOUD_USERNAME]: string;
+    [ConfigKey.HUAWEI_CLOUD_PASSWORD]: string;
+    [ConfigKey.HUAWEI_CLOUD_DOMAIN]: string;
+    [ConfigKey.CODEARTS_BASE_URL]: string;
+    [ConfigKey.PROJECT_ID]: string;
+    [ConfigKey.ROLE_ID]: string;
+};
+/**
+ * 部分配置映射（用于读取配置文件）
+ */
+export type PartialConfigMap = Partial<ConfigMap>;
+/**
+ * 输出格式类型
+ */
+export type OutputFormat = 'console' | 'csv' | 'json';

package/dist/types/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefectAnalysisType = void 0;
+exports.MUTABLE_CONFIG_KEYS = exports.IMMUTABLE_CONFIG_KEYS = exports.ConfigKey = exports.DefectAnalysisType = void 0;
 /**
  * 缺陷技术分析选项枚举
  * custom_field32（缺陷技术分析）字段的选项值枚举定义
@@ -23,3 +23,36 @@ var DefectAnalysisType;
     DefectAnalysisType["USAGE_AND_CONFIG"] = "\u4F7F\u7528\u53CA\u914D\u7F6E\u95EE\u9898";
     DefectAnalysisType["OTHER"] = "\u5176\u4ED6\u95EE\u9898";
 })(DefectAnalysisType || (exports.DefectAnalysisType = DefectAnalysisType = {}));
+/**
+ * 配置键枚举
+ * 用于类型安全的配置项访问
+ */
+var ConfigKey;
+(function (ConfigKey) {
+    // 不可变配置（只能通过 config 命令设置）
+    ConfigKey["HUAWEI_CLOUD_IAM_ENDPOINT"] = "HUAWEI_CLOUD_IAM_ENDPOINT";
+    ConfigKey["HUAWEI_CLOUD_REGION"] = "HUAWEI_CLOUD_REGION";
+    ConfigKey["HUAWEI_CLOUD_USERNAME"] = "HUAWEI_CLOUD_USERNAME";
+    ConfigKey["HUAWEI_CLOUD_PASSWORD"] = "HUAWEI_CLOUD_PASSWORD";
+    ConfigKey["HUAWEI_CLOUD_DOMAIN"] = "HUAWEI_CLOUD_DOMAIN";
+    ConfigKey["CODEARTS_BASE_URL"] = "CODEARTS_BASE_URL";
+    ConfigKey["PROJECT_ID"] = "PROJECT_ID";
+    // 可变配置（可以通过命令行参数覆盖）
+    ConfigKey["ROLE_ID"] = "ROLE_ID";
+})(ConfigKey || (exports.ConfigKey = ConfigKey = {}));
+/**
+ * 不可变配置键（只能通过 config 命令设置）
+ */
+exports.IMMUTABLE_CONFIG_KEYS = [
+    ConfigKey.HUAWEI_CLOUD_IAM_ENDPOINT,
+    ConfigKey.HUAWEI_CLOUD_REGION,
+    ConfigKey.HUAWEI_CLOUD_USERNAME,
+    ConfigKey.HUAWEI_CLOUD_PASSWORD,
+    ConfigKey.HUAWEI_CLOUD_DOMAIN,
+    ConfigKey.CODEARTS_BASE_URL,
+    ConfigKey.PROJECT_ID,
+];
+/**
+ * 可变配置键（可以通过命令行参数覆盖）
+ */
+exports.MUTABLE_CONFIG_KEYS = [ConfigKey.ROLE_ID];

package/dist/utils/config-loader.d.ts

@@ -1,22 +1,44 @@
-import { HuaweiCloudConfig } from '../types';
+import { HuaweiCloudConfig, OutputFormat, PartialConfigMap } from '../types';
+/**
+ * 获取全局配置文件路径
+ */
+export declare function getConfigPath(): string;
+/**
+ * 检查全局配置文件是否存在
+ */
+export declare function configExists(): boolean;
+/**
+ * 读取全局配置
+ */
+export declare function readConfig(): PartialConfigMap;
+/**
+ * 写入全局配置
+ * 支持动态配置项，自动按分组组织配置文件
+ */
+export declare function writeConfig(config: PartialConfigMap): void;
+/**
+ * 删除全局配置
+ */
+export declare function deleteConfig(): void;
 export interface CliOptions {
-    projectId?: string;
     roleId?: string;
-    username?: string;
-    password?: string;
-    domain?: string;
-    region?: string;
-    iamEndpoint?: string;
-    codeartsUrl?: string;
+    output?: string;
+    report?: boolean;
 }
 export interface LoadedConfig {
     projectId: string;
     roleIds: number[];
     config: HuaweiCloudConfig;
+    outputFormat: OutputFormat;
 }
 /**
- * 加载配置，优先级：命令行参数 > 当前目录 .env > 全局配置 > 默认值
+ * 加载配置，优先级：命令行参数 > 全局配置
  * @param cliOptions 命令行选项
  * @returns 加载的配置
  */
 export declare function loadConfig(cliOptions?: CliOptions): LoadedConfig;
+/**
+ * 获取最终合并后的配置（用于显示）
+ * @returns 合并后的配置映射
+ */
+export declare function getConfig(): PartialConfigMap;