@cnbcool/cnb-api-generate 2.4.7 → 2.5.1

package/built/codegen/api/build-query-value-expression.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQueryValueExpression = buildQueryValueExpression;
+const ts = __importStar(require("typescript"));
+const query_path_alias_1 = require("../../utils/query-path-alias");
+/**
+ * 构造请求参数对象里 `params:` / `_originParams.query:` 字段的值表达式。
+ *
+ * 规则：
+ *  - path 与 query 没有同名冲突时：直接返回 `Identifier(queryVarName)`，
+ *    生成代码形如 `params: __query`；
+ *  - 存在同名冲突时（如 `/{repo}/-/knowledge/base/query/{query}` 同时带 `?query=xxx`）：
+ *    返回对象字面量 `{ ...__query, ["<原始 key>"]: q_<原始 key>, ... }`，
+ *    通过计算属性把别名 `q_xxx` 映射回 swagger 里的原始 key，
+ *    保证发给后端的 query string key 与 swagger 契约一致。
+ */
+function buildQueryValueExpression(queryVarName, pathParams, queryParams) {
+    const aliasMap = (0, query_path_alias_1.collectQueryPathAliasMap)(pathParams, queryParams);
+    if (aliasMap.size === 0) {
+        return ts.factory.createIdentifier(queryVarName);
+    }
+    const properties = [
+        ts.factory.createSpreadAssignment(ts.factory.createIdentifier(queryVarName)),
+    ];
+    aliasMap.forEach((aliasName, originalName) => {
+        properties.push(ts.factory.createPropertyAssignment(ts.factory.createComputedPropertyName(ts.factory.createStringLiteral(originalName)), ts.factory.createIdentifier(aliasName)));
+    });
+    return ts.factory.createObjectLiteralExpression(properties, false);
+}

package/built/codegen/api/generate-api-function-ast-node.js

@@ -55,7 +55,7 @@ function generateApiFunctionASTNode(methodData, definitions, defintionsMap) {
     let dependencies = new Set();
     // 根据parameters的类型，处理请求中不同的数据的处理方式
     const { pathParams, bodyParams, queryParams } = (0, filter_api_param_1.filterApiParam)(path, parameters);
-    const { requestParamsASTNodes: paramASTNodes, reduxActionMap, dependencies: paramsDependencies, requestInterfaceASTNodes: paramsInterfaceASTNodes, } = (0, generate_function_params_ast_node_1.generateFunctionParamsASTNode)(methodData, pathParams, queryParams, bodyParams, defintionsMap);
+    const { requestParamsASTNodes: paramASTNodes, reduxActionMap, dependencies: paramsDependencies, requestInterfaceASTNodes: paramsInterfaceASTNodes, paramAliases, } = (0, generate_function_params_ast_node_1.generateFunctionParamsASTNode)(methodData, pathParams, queryParams, bodyParams, defintionsMap);
     if (paramsDependencies && paramsDependencies.size > 0) {
         dependencies = new Set([...dependencies, ...paramsDependencies]);
     }
@@ -113,7 +113,7 @@ function generateApiFunctionASTNode(methodData, definitions, defintionsMap) {
         ? undefined
         : ts.factory.createIdentifier(methodData.exportName), undefined, paramASTNodes, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
         ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(constants_1.CNB_REQUEST_RESULT_INTERFACE), [successApiReturnType, errorApiReturnType]),
-    ]), (0, generate_function_content_ast_node_1.generateFunctionContentASTNode)(methodData, successApiReturnType, errorApiReturnType, pathParams, queryParams, bodyParams)));
+    ]), (0, generate_function_content_ast_node_1.generateFunctionContentASTNode)(methodData, successApiReturnType, errorApiReturnType, pathParams, queryParams, bodyParams, paramAliases)));
     for (const dependency of dependencies) {
         const defintion = defintionsMap[dependency];
         requestFileDependenciesASTNodes.push((0, generate_import_ast_node_1.generateImportAstNode)(defintion.exportName, defintion.filename, false, category, defintion.type));

package/built/codegen/api/generate-function-content-ast-node.js

@@ -38,11 +38,17 @@ const ts = __importStar(require("typescript"));
 const constants_1 = require("../../constants");
 const generate_request_url_ast_node_1 = require("./generate-request-url-ast-node");
 const is_skills_1 = require("../../utils/is-skills");
-function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchErrorResponse, pathParams, queryParams, bodyParams) {
+const build_query_value_expression_1 = require("./build-query-value-expression");
+function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchErrorResponse, pathParams, queryParams, bodyParams, paramAliases) {
+    var _a, _b, _c, _d;
+    const queryVarName = (_a = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.queryName) !== null && _a !== void 0 ? _a : constants_1.CNB_REQUEST_PARAM_QUERY_NAME;
+    const reqVarName = (_b = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.reqName) !== null && _b !== void 0 ? _b : constants_1.CNB_REQUEST_PARAM_REQ_NAME;
+    const optionsVarName = (_c = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.optionsName) !== null && _c !== void 0 ? _c : constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME;
+    const axiosConfigVarName = (_d = paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.axiosConfigName) !== null && _d !== void 0 ? _d : constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME;
     const requestParams = [
-        ts.factory.createSpreadAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME)),
-        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_NEXT_REQ), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_REQ_NAME)),
-        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME)),
+        ts.factory.createSpreadAssignment(ts.factory.createIdentifier(axiosConfigVarName)),
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_NEXT_REQ), ts.factory.createIdentifier(reqVarName)),
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), ts.factory.createIdentifier(optionsVarName)),
     ];
     // 请求路径
     requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_URL), (0, generate_request_url_ast_node_1.generateRequestUrlASTNode)(methodData.path, pathParams)));
@@ -52,11 +58,12 @@ function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchE
     requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_METHOD), ts.factory.createStringLiteral(methodData.method)));
     // 请求query
     if (queryParams && queryParams.length > 0) {
-        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_KEY_NAME), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_NAME)));
+        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_KEY_NAME), (0, build_query_value_expression_1.buildQueryValueExpression)(queryVarName, pathParams, queryParams)));
     }
     // 请求body
     if (bodyParams) {
-        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_DATA), ts.factory.createIdentifier(bodyParams.name)));
+        const bodyVarName = (paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.bodyParamName) || bodyParams.name;
+        requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_CONFIG_DATA), ts.factory.createIdentifier(bodyVarName)));
     }
     // 生成skills时，请求参数需要包含_originalParams，用于后处理时使用
     if ((0, is_skills_1.isSkills)()) {
@@ -72,10 +79,11 @@ function generateFunctionContentASTNode(methodData, fetchSuccessResponse, fetchE
             objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PATH_PARAM_ORIGIN_NAME), ts.factory.createObjectLiteralExpression(pathParams.map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name), undefined)), false)));
         }
         if (queryParams.length > 0) {
-            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_QUERY_PARAM_ORIGIN_NAME), ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_NAME)));
+            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_QUERY_PARAM_ORIGIN_NAME), (0, build_query_value_expression_1.buildQueryValueExpression)(queryVarName, pathParams, queryParams)));
         }
         if (bodyParams) {
-            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_BODY_PARAM_ORIGIN_NAME), ts.factory.createIdentifier(bodyParams.name)));
+            const bodyVarName = (paramAliases === null || paramAliases === void 0 ? void 0 : paramAliases.bodyParamName) || bodyParams.name;
+            objectLiteralExpression.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_BODY_PARAM_ORIGIN_NAME), ts.factory.createIdentifier(bodyVarName)));
         }
         requestParams.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier(constants_1.CNB_REQUEST_ORIGIN_PARAM_NAME), ts.factory.createObjectLiteralExpression(objectLiteralExpression, true)));
     }

package/built/codegen/api/generate-function-params-ast-node.js

@@ -42,8 +42,13 @@ const get_keyword_type_node_1 = require("../../utils/get-keyword-type-node");
 const is_english_only_1 = require("../../utils/is-english-only");
 const constants_1 = require("../../constants");
 const md_array_type_content_ast_node_1 = require("../types/md-array-type-content-ast-node");
+const compute_param_aliases_1 = require("../../utils/compute-param-aliases");
+const query_path_alias_1 = require("../../utils/query-path-alias");
 function generateFunctionParamsASTNode(methodData, pathParams, queryParams, bodyParams, defintionsMap) {
     var _a;
+    // 计算保留变量名（query/req/options/axiosConfig）的安全别名，
+    // 避免与 path/body 参数重名导致 "Argument name clash" 等语法错误。
+    const paramAliases = (0, compute_param_aliases_1.computeParamAliases)(pathParams, bodyParams);
     // request函数参数
     const requestParamsASTNodes = [];
     const requestInterfaceASTNodes = [];
@@ -60,8 +65,29 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
         const paramsInterfaceName = `${(0, format_interface_name_1.formatInterfaceName)(methodData.exportName)}Params`;
         const paramMap = {};
         const firstParams = [];
-        // 排重
-        [...pathParams, ...queryParams].map((item) => {
+        // path 参数与 query 参数同名时（如 /{repo}/-/knowledge/base/query/{query} 同时带 ?query=xxx）：
+        // 两者语义不同，需要同时在类型里表达：
+        //   - path 字段沿用 swagger 的原名（URL 模板里的字面占位，必须保持原名）；
+        //   - query 字段通过 `q_<name>` 别名字段在 interface 中暴露，
+        //     运行时再通过计算属性把别名映射回 swagger 的原始 key（见 generate-function-content-ast-node.ts）。
+        const pathParamNameSet = new Set(pathParams.map((p) => p.name));
+        [
+            ...pathParams,
+            ...queryParams.map((q) => {
+                if (!pathParamNameSet.has(q.name))
+                    return q;
+                // 同名冲突：拷贝 query 参数并改名为 `q_<name>`，以便在 interface 中作为独立字段出现
+                const aliasName = (0, query_path_alias_1.getQueryPathAliasName)(q.name);
+                const aliasDesc = q.description
+                    ? `${q.description}（query string 参数；该路由 path 也存在同名字段，为避免冲突此处使用别名 ${aliasName}）`
+                    : `query string 参数；该路由 path 也存在同名字段，为避免冲突此处使用别名 ${aliasName}`;
+                return {
+                    ...q,
+                    name: aliasName,
+                    description: aliasDesc,
+                };
+            }),
+        ].map((item) => {
             paramMap[item.name] = item;
         });
         Object.keys(paramMap).forEach((key) => {
@@ -146,10 +172,21 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
         const pathParamsBindingElements = pathParams.map((item) => {
             return ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(item.name), undefined);
         });
+        // 同名 path/query 别名字段（如 q_query），需要单独从对象中解构出来，
+        // 避免被 `...__query` 吞掉后再做重映射（保留了可读性，并与 generate-function-content-ast-node 联动）。
+        const aliasQueryBindingElements = (queryParams || [])
+            .filter((q) => pathParamNameSet.has(q.name))
+            .map((q) => {
+            const aliasName = (0, query_path_alias_1.getQueryPathAliasName)(q.name);
+            return ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(aliasName), undefined);
+        });
         // 创建解构参数
-        const deconstructionParams = [...pathParamsBindingElements];
+        const deconstructionParams = [
+            ...pathParamsBindingElements,
+            ...aliasQueryBindingElements,
+        ];
         if (queryParams && queryParams.length > 0) {
-            deconstructionParams.push(ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_QUERY_NAME), undefined));
+            deconstructionParams.push(ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(paramAliases.queryName), undefined));
         }
         requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(deconstructionParams), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(paramsInterfaceName), undefined), undefined));
         // redux action参数定义
@@ -176,6 +213,11 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
     // eslint-disable-next-line @typescript-eslint/prefer-for-of
     for (let i = 0; i < allRequestParams.length; i++) {
         const param = allRequestParams[i];
+        // 仅 body 参数需要用别名替换标识符；单个 path 参数保留原名（必须等于 URL 占位符）
+        const isBodyParam = bodyParams !== null && param === bodyParams;
+        const effectiveParamName = isBodyParam && paramAliases.bodyParamName
+            ? paramAliases.bodyParamName
+            : param.name;
         if (param === null || param === void 0 ? void 0 : param.schema) {
             // 多维数组处理
             if (param.schema.type &&
@@ -192,13 +234,13 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
                 requestInterfaceASTNodes.push(ts.factory.createExpressionStatement(ts.factory.createStringLiteral(`<$${paramsBodyName}$>`)));
                 // 创建interface主体
                 requestInterfaceASTNodes.push(ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(paramsBodyName), undefined, returnType));
-                requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier(param.name), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(paramsBodyName), undefined), undefined));
+                requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier(effectiveParamName), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(paramsBodyName), undefined), undefined));
                 if (typeDependencies && typeDependencies.size > 0) {
                     dependencies = new Set([...dependencies, ...typeDependencies]);
                 }
                 // redux action参数定义
                 reduxActionMap.paramsSequence.push({
-                    param: param.name,
+                    param: effectiveParamName,
                     typeLiteral: paramsBodyName,
                     typeLiteralLabel: constants_1.TypeLiteralLabel.Quoted,
                     required: param.required,
@@ -207,7 +249,14 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
             }
             else {
                 const [imports, astNode, paramsSequenceItem] = (0, generate_function_refs_type_params_ast_node_1.generateFunctionReferenceTypeDataParamsASTNode)(param, defintionsMap);
-                astNode && requestParamsASTNodes.push(astNode);
+                if (astNode && isBodyParam && effectiveParamName !== param.name) {
+                    // 替换 body 参数的标识符为别名
+                    requestParamsASTNodes.push(ts.factory.updateParameterDeclaration(astNode, astNode.modifiers, astNode.dotDotDotToken, ts.factory.createIdentifier(effectiveParamName), astNode.questionToken, astNode.type, astNode.initializer));
+                    paramsSequenceItem.param = effectiveParamName;
+                }
+                else {
+                    astNode && requestParamsASTNodes.push(astNode);
+                }
                 if (imports && imports.size > 0) {
                     dependencies = new Set([...dependencies, ...imports]);
                 }
@@ -216,11 +265,14 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
             }
         }
         else {
-            const normalParamsASTNode = (0, generate_function_normal_params_ast_node_1.generateFunctionNormalParamsASTNode)(param);
+            let normalParamsASTNode = (0, generate_function_normal_params_ast_node_1.generateFunctionNormalParamsASTNode)(param);
+            if (isBodyParam && effectiveParamName !== param.name) {
+                normalParamsASTNode = ts.factory.updateParameterDeclaration(normalParamsASTNode, normalParamsASTNode.modifiers, normalParamsASTNode.dotDotDotToken, ts.factory.createIdentifier(effectiveParamName), normalParamsASTNode.questionToken, normalParamsASTNode.type, normalParamsASTNode.initializer);
+            }
             requestParamsASTNodes.push(normalParamsASTNode);
             // redux action参数定义
             reduxActionMap.paramsSequence.push({
-                param: param.name,
+                param: effectiveParamName,
                 typeLiteral: param.type || null,
                 typeLiteralLabel: constants_1.TypeLiteralLabel.Native,
                 required: param.required,
@@ -229,9 +281,13 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
     }
     // 添加requestConfig
     requestParamsASTNodes.push(ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern([
-        ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_REQ_NAME), undefined),
-        ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), undefined),
-        ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME), undefined),
+        ts.factory.createBindingElement(undefined, paramAliases.reqName === constants_1.CNB_REQUEST_PARAM_REQ_NAME
+            ? undefined
+            : ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_REQ_NAME), ts.factory.createIdentifier(paramAliases.reqName), undefined),
+        ts.factory.createBindingElement(undefined, paramAliases.optionsName === constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME
+            ? undefined
+            : ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME), ts.factory.createIdentifier(paramAliases.optionsName), undefined),
+        ts.factory.createBindingElement(ts.factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, ts.factory.createIdentifier(paramAliases.axiosConfigName), undefined),
     ]), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(constants_1.CNB_REQUEST_PARAM_TYPE_NAME), undefined), ts.factory.createObjectLiteralExpression([], false)));
     // redux action参数定义
     reduxActionMap.paramsSequence.push({
@@ -245,5 +301,6 @@ function generateFunctionParamsASTNode(methodData, pathParams, queryParams, body
         reduxActionMap,
         dependencies,
         requestInterfaceASTNodes,
+        paramAliases,
     };
 }

package/built/utils/compute-param-aliases.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeParamAliases = computeParamAliases;
+const constants_1 = require("../constants");
+const RESERVED_DEFAULTS = {
+    queryName: constants_1.CNB_REQUEST_PARAM_QUERY_NAME,
+    reqName: constants_1.CNB_REQUEST_PARAM_REQ_NAME,
+    optionsName: constants_1.CNB_REQUEST_PARAM_OPTIONS_NAME,
+    axiosConfigName: constants_1.CNB_REQUEST_AXIOS_CONFIG_NAME,
+};
+/**
+ * 给定一个目标变量名 base 和已被占用的名字集合 used，
+ * 返回不与 used 冲突的安全名（依次尝试 _base、__base 等）。
+ */
+function pickUniqueName(base, used) {
+    if (!used.has(base))
+        return base;
+    let candidate = `_${base}`;
+    while (used.has(candidate)) {
+        candidate = `_${candidate}`;
+    }
+    return candidate;
+}
+/**
+ * 根据 path/body 参数名计算需要使用的保留变量名别名，避免命名冲突。
+ *
+ * 注意 path 参数名是"硬约束"（必须等于 URL 模板中的占位符名），
+ * 因此优先占用 path 参数名，再依次给 body / 保留变量分配安全名。
+ */
+function computeParamAliases(pathParams = [], bodyParams = null) {
+    var _a;
+    const used = new Set();
+    pathParams.forEach((p) => {
+        if (p === null || p === void 0 ? void 0 : p.name)
+            used.add(p.name);
+    });
+    // body 参数名：与 path 参数 / 保留名冲突时改名
+    const originalBodyName = (_a = bodyParams === null || bodyParams === void 0 ? void 0 : bodyParams.name) !== null && _a !== void 0 ? _a : '';
+    const bodyParamName = originalBodyName
+        ? pickUniqueName(originalBodyName, used)
+        : '';
+    if (bodyParamName)
+        used.add(bodyParamName);
+    const aliases = {
+        ...RESERVED_DEFAULTS,
+        bodyParamName,
+    };
+    // 保留变量按顺序分配，先分配出去的别名也要避免后续被占用
+    ['queryName', 'reqName', 'optionsName', 'axiosConfigName'].forEach((key) => {
+        const safe = pickUniqueName(RESERVED_DEFAULTS[key], used);
+        aliases[key] = safe;
+        used.add(safe);
+    });
+    return aliases;
+}

package/built/utils/flatten-tool-options.js

@@ -36,20 +36,25 @@ function flattenToolOptions(toolInfo) {
             });
         }
     }
-    // query 参数
+    // query 参数：与 path 同名时，optKey 前缀 q- 以避免 Commander 选项名冲突
     if (queryDef) {
+        const pathKeys = new Set(pathDef ? Object.keys(pathDef) : []);
         for (const [key, param] of Object.entries(queryDef)) {
             const valuePlaceholder = (0, option_value_flag_1.optionValueFlag)(param.type);
             const rawDesc = (0, trim_summary_1.trimSummary)(param.description || '');
             const desc = param.required ? `[必填] ${rawDesc}` : rawDesc;
+            const conflict = pathKeys.has(key);
+            const optKey = conflict ? `q-${key}` : key;
             const opt = {
-                optKey: key,
+                optKey,
                 valuePlaceholder,
                 description: desc,
                 required: !!param.required,
                 isArray: false,
                 source: 'query',
             };
+            if (conflict)
+                opt.originalName = key;
             if (param.enum)
                 opt.choices = param.enum;
             if (param.default !== undefined)

package/built/utils/query-path-alias.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUERY_PATH_ALIAS_PREFIX = void 0;
+exports.getQueryPathAliasName = getQueryPathAliasName;
+exports.collectQueryPathAliasMap = collectQueryPathAliasMap;
+/**
+ * path 参数与 query 参数同名时，query 字段在生成的 interface / 函数解构里
+ * 统一使用的别名前缀。
+ *
+ * 例如 swagger 中 `/{repo}/-/knowledge/base/query/{query}` 同时存在
+ *   { name: 'query', in: 'path' }
+ *   { name: 'query', in: 'query' }
+ * 两个语义不同的参数。我们保留 path 字段的原名（URL 占位），
+ * 而 query 字段改名为 `q_query`，运行时再用计算属性映射回原始 key。
+ */
+exports.QUERY_PATH_ALIAS_PREFIX = 'q_';
+/**
+ * 给定 swagger 原始 query 参数名，返回它在生成代码里的别名。
+ */
+function getQueryPathAliasName(originalName) {
+    return `${exports.QUERY_PATH_ALIAS_PREFIX}${originalName}`;
+}
+/**
+ * 收集 query 参数中名字与 path 参数同名的项，返回 `原始名 -> 别名` 的映射。
+ * 没有冲突时返回空 Map。
+ */
+function collectQueryPathAliasMap(pathParams = [], queryParams = []) {
+    const map = new Map();
+    if (!pathParams.length || !queryParams.length)
+        return map;
+    const pathNameSet = new Set(pathParams.map((p) => p.name));
+    for (const q of queryParams) {
+        if (pathNameSet.has(q.name)) {
+            map.set(q.name, getQueryPathAliasName(q.name));
+        }
+    }
+    return map;
+}

package/client/index.ts

@@ -7,6 +7,7 @@ import { registerFallbackAction } from './lib/register-fallback';
 import { registerLoginCommand } from './lib/login';
 import { registerLogoutCommand } from './lib/logout';
 import { registerStatusCommand } from './lib/status';
+import { registerGitCredentialCommand } from './lib/git-credential';
 
 // ============================================================
 // Commander 程序定义
@@ -30,6 +31,7 @@ program
 registerLoginCommand(program);
 registerLogoutCommand(program);
 registerStatusCommand(program);
+registerGitCredentialCommand(program);
 registerModuleCommands(program);
 registerFallbackAction(program);
 

package/client/lib/format-params.ts

@@ -48,8 +48,7 @@ export function formatParams(
     const bodyProps = paramDefs.body?.schema?.properties || {};
 
     const reservedKeys = new Set([
-      'module', 'tool', 'help', 'short', 'verbose',
-      'path', 'query', 'data', 'h', 'v',
+      'module', 'tool', 'help', 'short', 'verbose', 'h', 'v',
     ]);
 
     // 收集 array<object> 展开字段的临时存储：{ arrayName: { propName: string[] } }
@@ -97,6 +96,18 @@ export function formatParams(
         // 归入 path
         if (!formatted.path) formatted.path = {};
         formatted.path[key] = value;
+        // path 与 query 同名时，query 参数通过 q- 前缀传入（见下方 q- 分支）；
+        // 但若调用方直接用 --<name> 传了值（旧习惯/兼容），且 queryDef 里也有同名项，
+        // 则同时回填到 query，保证 URL 查询参数也被带上。
+        if (queryDef[key]) {
+          if (!formatted.query) formatted.query = {};
+          const paramType = queryDef[key].type;
+          if (paramType === 'number' && typeof value === 'string' && !isNaN(Number(value))) {
+            formatted.query[key] = Number(value);
+          } else {
+            formatted.query[key] = value;
+          }
+        }
       } else if (queryDef[key]) {
         // 归入 query
         if (!formatted.query) formatted.query = {};
@@ -106,6 +117,17 @@ export function formatParams(
         } else {
           formatted.query[key] = value;
         }
+      } else if ((key.startsWith('q-') || key.startsWith('q_'))
+        && queryDef[key.replace(/^q[-_]/, '')]) {
+        // query 参数与 path 同名时，CLI 层以 q- 前缀区分，这里还原为真实 query key
+        const originalKey = key.replace(/^q[-_]/, '');
+        if (!formatted.query) formatted.query = {};
+        const paramType = queryDef[originalKey].type;
+        if (paramType === 'number' && typeof value === 'string' && !isNaN(Number(value))) {
+          formatted.query[originalKey] = Number(value);
+        } else {
+          formatted.query[originalKey] = value;
+        }
       } else if (bodyProps[key]) {
         // body 字段（无冲突，直接用原 key）
         if (!formatted.data) formatted.data = {};

package/client/lib/git-credential.ts

@@ -0,0 +1,182 @@
+import { Command } from 'commander';
+import { resolveToken } from '../utils/resolve-token';
+
+/**
+ * 用作 git credential helper。
+ *
+ * 在 .gitconfig 中配置：
+ * [credential]
+ *   helper = "<cli> git-credential"
+ *   useHttpPath = true
+ *
+ * git 在执行需要凭据的操作时，会以 `get`、`store`、`erase` 之一作为 action 调用本命令，
+ * 并通过 stdin 传入若干 `key=value` 形式的字段（protocol/host/path 等）。
+ * 我们仅处理 `get`：根据 host 白名单校验后，从后端获取凭据，按 git-credential
+ * 协议把 `username=...` / `password=...` 写到 stdout；`store` / `erase` 直接忽略。
+ */
+
+interface GitCredentialInput {
+  protocol?: string;
+  host?: string;
+  path?: string;
+  [key: string]: string | undefined;
+}
+
+interface Credential {
+  username: string;
+  password: string;
+}
+
+const ALLOWED_HOSTS = ['cnb.cool', 'cnb.woa.com'];
+
+/** git-credential get 等待 stdin 的最长时间，避免 git 无限挂起。 */
+const GET_INPUT_TIMEOUT_MS = 8000;
+
+export function registerGitCredentialCommand(program: Command): void {
+  program
+    .command('git-credential <action>')
+    .description('作为 git credential helper，向 git 提供 CNB 凭据（仅供 git 内部调用）')
+    .allowUnknownOption()
+    .allowExcessArguments()
+    .helpOption('-h, --help', '显示帮助文档')
+    .action(async (action: string, _opts, cmd: Command) => {
+      // 透传给用户：剩余的位置参数都视为自定义参数
+      const customArgs = cmd.args.slice(0, -1);
+      if (customArgs.length > 0) {
+        console.error(`[git-credential]: custom args: ${customArgs.join(' ')}`);
+      }
+
+      // store / erase：保持与原 helper 一致，忽略并退出 0
+      if (action === 'store' || action === 'erase') {
+        console.error(`[git-credential]: ${action} ignored`);
+        process.exit(0);
+      }
+
+      if (action !== 'get') {
+        console.error(`[git-credential]: unknown action: ${action}`);
+        process.exit(1);
+      }
+
+      // get：从 stdin 读取字段并输出凭据
+      try {
+        const input = await readStdin(GET_INPUT_TIMEOUT_MS);
+        const data = parseText(input, '=') as GitCredentialInput;
+        normalizePath(data);
+
+        await auth(data);
+        process.exit(0);
+      } catch (err: any) {
+        console.error(err?.message ? err.message : String(err));
+        process.exit(2);
+      }
+    });
+}
+
+/**
+ * 校验白名单并向后端获取凭据，按照 git-credential 协议输出 username/password。
+ */
+async function auth(data: GitCredentialInput): Promise<void> {
+  const { host } = data;
+  console.error(
+    `[git-credential]: for ${data.protocol}://${data.host}/${data.path ?? ''}`,
+  );
+
+  // 必须校验域名，否则传入第三方域名就会被盗密码
+  if (!host || !ALLOWED_HOSTS.includes(host)) {
+    throw new Error(`unknown host: ${host}`);
+  }
+
+  const credential = await fetchCredential(data);
+
+  // git-credential 协议：通过 stdout 输出 key=value
+  process.stdout.write(`username=${credential.username}\n`);
+  process.stdout.write(`password=${credential.password}\n`);
+
+  console.error('[git-credential]: done');
+}
+
+async function fetchCredential(_data: GitCredentialInput): Promise<Credential> {
+  // 使用 resolveToken 获取 access_token 作为 password，username 固定为 cnb
+  const token = await resolveToken();
+  return {
+    username: 'cnb',
+    password: token,
+  };
+}
+
+/**
+ * git-credential 协议中 path 通常包含仓库目录，需要规范化。
+ */
+function normalizePath(data: GitCredentialInput): void {
+  if (!data.path) return;
+  if (data.path.endsWith('.git')) {
+    data.path = data.path.slice(0, -4);
+  } else if (data.path.endsWith('.git/info/lfs')) {
+    data.path = data.path.slice(0, -13);
+  }
+}
+
+/**
+ * 从 stdin 收集所有数据。
+ *
+ * 同原始 helper 一致：必须设置超时，否则 git 在拿不到响应时会让用户输入账号密码，
+ * 进而把进程挂起。同时支持单字节回车（0x0a）作为提前结束的信号。
+ */
+function readStdin(timeoutMs: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const buff: Buffer[] = [];
+    let settled = false;
+
+    const finish = (): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(Buffer.concat(buff).toString('utf-8'));
+    };
+
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      console.error('[git-credential]: timeout occurred');
+      reject(new Error('stdin timeout'));
+    }, timeoutMs);
+
+    process.stdin.on('data', (chunk: Buffer) => {
+      buff.push(chunk);
+      // git 会在最后发送一个空行（仅一个 \n）作为结束标志
+      if (chunk.length === 1 && chunk[0] === 0x0a) {
+        finish();
+      }
+    });
+
+    process.stdin.on('end', () => {
+      finish();
+    });
+
+    process.stdin.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * 把 git 通过 stdin 传入的多行 key=value 文本解析为对象。
+ */
+function parseText(content: string, separator: string): Record<string, string> {
+  return content
+    .split(/(?:\r\n|\r|\n)/)
+    .filter(Boolean)
+    .map((line) => {
+      const idx = line.indexOf(separator);
+      const key = idx >= 0 ? line.substring(0, idx).trim() : line.trim();
+      const value = idx >= 0 ? line.substring(idx + 1).trim() : '';
+      return { key, value };
+    })
+    .reduce<Record<string, string>>((acc, { key, value }) => {
+      if (key) acc[key] = value;
+      return acc;
+    }, {});
+}

package/client/utils/get-token-env-key.ts

@@ -0,0 +1,7 @@
+// connector name 由 WorkBuddy 与 CLI 团队约定，CLI 写死
+const CONNECTOR_NAME = 'cnb-app';
+
+export function getTokenEnvKey(): string {
+  // cnb-app → WORKBUDDY_TOKEN_URL_CNB_APP
+  return `WORKBUDDY_TOKEN_URL_${CONNECTOR_NAME.toUpperCase().replace(/-/g, '_')}`;
+}

package/client/utils/is-workbuddy-sandbox.ts

@@ -0,0 +1,3 @@
+export function isWorkBuddySandbox(): boolean {
+  return !!process.env.AGENTOS_RUNTIME_ID;
+}

package/client/utils/refresh-token.ts

@@ -10,7 +10,7 @@ export async function refreshAccessToken(store: TokenStore): Promise<string> {
     throw new Error('no refresh_token');
   }
 
-  const platformURL = store.platform_url || 'https://cnb-dev.woa.com';
+  const platformURL = store.platform_url || 'https://cnb.cool';
   const clientID = store.client_id || process.env.OAUTH2_CLIENT_ID || 'cnb_cli';
   const tokenURL = `${platformURL.replace(/\/+$/, '')}/oauth2/token`;
 

package/client/utils/resolve-token.ts

@@ -1,3 +1,5 @@
+import { getTokenEnvKey } from './get-token-env-key';
+import { isWorkBuddySandbox } from './is-workbuddy-sandbox';
 import { loadToken } from './load-token';
 import { refreshAccessToken } from './refresh-token';
 
@@ -9,6 +11,38 @@ import { refreshAccessToken } from './refresh-token';
  * 刷新失败或无 refresh_token 时终止进程并提示用户重新登录。
  */
 export async function resolveToken(): Promise<string> {
+  // WorkBuddy 沙箱环境，从远程接口获取 token
+  if (isWorkBuddySandbox()) {
+    const tokenURL = process.env[getTokenEnvKey()];
+    if (!tokenURL) {
+      console.error(`未找到环境变量 ${getTokenEnvKey()}，无法在 WorkBuddy 沙箱环境中获取 token。`);
+      process.exit(1);
+    }
+
+    try {
+      const resp = await fetch(tokenURL, {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+      });
+
+      if (!resp.ok) {
+        console.error(`从 WorkBuddy 获取 token 失败，HTTP 状态码: ${resp.status} ${resp.statusText}`);
+        process.exit(1);
+      }
+
+      const body: any = await resp.json();
+      if (body?.code !== 0 || !body?.data?.access_token) {
+        console.error(`从 WorkBuddy 获取 token 失败，响应内容异常: ${JSON.stringify(body)}`);
+        process.exit(1);
+      }
+
+      return body.data.access_token as string;
+    } catch (err: any) {
+      console.error(`从 WorkBuddy 获取 token 失败: ${err?.message || err}`);
+      process.exit(1);
+    }
+  }
+
   // 环境变量优先 CodeBuddy
   if (process.env.CNB_TOKEN_FOR_CODEBUDDY) {
     if (!process.env.CNB_NPC_SLUG && process.env.CNB_NPC_NAME === 'CodeBuddy') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cnbcool/cnb-api-generate",
-  "version": "2.4.7",
+  "version": "2.5.1",
   "main": "./built/index.js",
   "module": "./src/index.ts",
   "types": "./src/index.ts",