wormajs 0.0.1

package/dist/plugins/presets/aiDoc.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiDoc = aiDoc;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const constant_1 = require("../../constant");
+const logger_1 = require("../../helper/logger");
+const template_1 = require("../../template");
+const nodeRequire = (0, node_module_1.createRequire)(__filename);
+const SKILLS_SUPPORTED_AGENTS_URL = 'https://www.npmjs.com/package/skills#supported-agents';
+const prefix = '[plugin: aiDoc]';
+function aiDoc(config) {
+    const outputDirName = config?.outputDir ?? 'aidocs';
+    const customTemplatePath = config?.template;
+    const installSkillEnabled = config?.installSkill ?? false;
+    let capturedOutput = '';
+    let capturedServerName = '';
+    return {
+        name: constant_1.PluginName.AI_DOC,
+        config({ config: generatorConfig }) {
+            capturedOutput = generatorConfig.output ?? '';
+            capturedServerName = generatorConfig.serverName ?? '';
+            return generatorConfig;
+        },
+        async codeGenerated({ error, data: templateData, projectPath, outputDir, renderTemplate }) {
+            if (error)
+                return;
+            if (!templateData)
+                return;
+            const outputBase = outputDir || node_path_1.default.resolve(projectPath, capturedOutput);
+            const aidocsDir = node_path_1.default.resolve(outputBase, outputDirName);
+            const templatePath = customTemplatePath
+                ? (node_path_1.default.isAbsolute(customTemplatePath) ? customTemplatePath : node_path_1.default.resolve(projectPath, customTemplatePath))
+                : (0, template_1.getPresetTemplatePath)(constant_1.PresetTemplateName.AI_DOC);
+            const serverName = capturedServerName || templateData.title || 'API';
+            // Compute file location for each API (relative path from project root to generated file)
+            // Skip fileLocation for alova-globals since APIs are called globally, not from a specific file
+            const isGlobals = templateData.config?.templateName === 'alova-globals';
+            const outputRel = node_path_1.default.relative(projectPath, outputBase);
+            const enrichedData = {
+                ...templateData,
+                allApis: templateData.allApis.map(api => ({
+                    ...api,
+                    // Store the generated file location where this API's code lives
+                    ...(isGlobals ? {} : { fileLocation: `${outputRel.replace(/\\/g, '/')}/${api.tag}` }),
+                })),
+                tagedApis: templateData.tagedApis.map(group => ({
+                    ...group,
+                    apis: group.apis.map(api => ({
+                        ...api,
+                        ...(isGlobals ? {} : { fileLocation: `${outputRel.replace(/\\/g, '/')}/${group.tagName}` }),
+                    })),
+                })),
+            };
+            await renderTemplate?.({
+                templatePath,
+                type: templateData.type,
+                outputDir: aidocsDir,
+                data: {
+                    ...enrichedData,
+                    serverName,
+                },
+            });
+            if (installSkillEnabled) {
+                const { agent } = resolveAgent(projectPath);
+                installSkill(aidocsDir, agent, projectPath);
+            }
+        },
+    };
+}
+/**
+ * Resolve the target coding agent from `.env.local` in the project root.
+ *
+ * If the file does not exist, it will be created and `.gitignore` will be
+ * updated to ignore `*.local` files. An error is then thrown asking the user
+ * to set `agent=<coding-agent>`.
+ *
+ * If `agent` is missing, an error is thrown with guidance.
+ */
+function resolveAgent(projectPath) {
+    const envFilePath = node_path_1.default.join(projectPath, '.env.local');
+    if (!node_fs_1.default.existsSync(envFilePath)) {
+        createEnvLocalFile(envFilePath);
+        ensureGitIgnoreLocal(projectPath);
+        throw logger_1.logger.throwError(`${prefix}Created .env.local at project root. Please set the coding agent you are using, e.g. agent=cursor. Supported agents list: ${SKILLS_SUPPORTED_AGENTS_URL}`);
+    }
+    const content = node_fs_1.default.readFileSync(envFilePath, 'utf-8');
+    const agent = parseEnvValue(content, 'agent');
+    if (!agent) {
+        throw logger_1.logger.throwError(`${prefix}Missing "agent" in .env.local at project root. Please set the coding agent you are using, e.g. agent=cursor. Supported agents list: ${SKILLS_SUPPORTED_AGENTS_URL}`);
+    }
+    return { agent };
+}
+/**
+ * Resolve the absolute path to the `skills` CLI installed alongside this package.
+ */
+function resolveSkillsCli() {
+    try {
+        const skillsPkgPath = nodeRequire.resolve('skills/package.json');
+        return node_path_1.default.join(node_path_1.default.dirname(skillsPkgPath), 'bin', 'cli.mjs');
+    }
+    catch {
+        throw logger_1.logger.throwError('Could not resolve the "skills" CLI. Make sure "skills" is installed as a dependency of @alova/worma.');
+    }
+}
+/**
+ * Install the generated skill into the configured coding agent using the
+ * `skills` CLI.
+ */
+function installSkill(skillPath, agent, projectPath) {
+    // Normalize to forward slashes so the shell command works across platforms
+    const resolvedSkillPath = node_path_1.default.resolve(skillPath).replace(/\\/g, '/');
+    const skillsCli = resolveSkillsCli();
+    try {
+        (0, node_child_process_1.execSync)(`node "${skillsCli}" add "${resolvedSkillPath}" -a "${agent}" -y`, {
+            cwd: projectPath,
+            stdio: 'pipe',
+            encoding: 'utf-8',
+        });
+    }
+    catch (error) {
+        console.error(`${prefix}Failed to install skill to "${agent}". Make sure the skill is valid and the target agent is supported.`, error.stack);
+        throw logger_1.logger.throwError(error);
+    }
+}
+function createEnvLocalFile(envFilePath) {
+    const content = `# Worma aiDoc skill installer configuration
+# Please set the coding agent you are using (e.g. cursor, claude-code, windsurf).
+# Supported agents list: ${SKILLS_SUPPORTED_AGENTS_URL}
+agent=
+`;
+    node_fs_1.default.writeFileSync(envFilePath, content, 'utf-8');
+}
+function ensureGitIgnoreLocal(projectPath) {
+    const gitignorePath = node_path_1.default.join(projectPath, '.gitignore');
+    const pattern = '*.local';
+    let content = '';
+    if (node_fs_1.default.existsSync(gitignorePath)) {
+        content = node_fs_1.default.readFileSync(gitignorePath, 'utf-8');
+        const lines = content.split(/\r?\n/);
+        if (lines.some(line => line.trim() === pattern || line.trim() === '*.local/')) {
+            return;
+        }
+    }
+    const prefix = content === '' || content.endsWith('\n') ? '' : '\n';
+    node_fs_1.default.writeFileSync(gitignorePath, `${content}${prefix}${pattern}\n`, 'utf-8');
+}
+function parseEnvValue(content, key) {
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('#') || !trimmed.includes('=')) {
+            continue;
+        }
+        const eqIndex = trimmed.indexOf('=');
+        const k = trimmed.slice(0, eqIndex).trim();
+        let v = trimmed.slice(eqIndex + 1).trim();
+        // Remove surrounding quotes if present
+        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith('\'') && v.endsWith('\''))) {
+            v = v.slice(1, -1);
+        }
+        if (k === key) {
+            return v;
+        }
+    }
+    return undefined;
+}
+exports.default = aiDoc;

package/dist/plugins/presets/apifox.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apifox = apifox;
+const constant_1 = require("../../constant");
+function apifox({ projectId, locale = 'zh-CN', apifoxVersion = '2024-03-28', scopeType = 'ALL', selectedEndpointIds = [], selectedTags = [], selectedFolderIds = [], excludedByTags = [], apifoxToken, oasVersion = '3.0', exportFormat = 'JSON', includeApifoxExtensionProperties = false, addFoldersToTags = false, environmentIds, branchId, moduleId, }) {
+    const body = {
+        scope: {
+            type: scopeType,
+            excludedByTags,
+        },
+        options: {
+            includeApifoxExtensionProperties,
+            addFoldersToTags,
+        },
+        oasVersion,
+        exportFormat,
+        environmentIds,
+        branchId,
+        moduleId,
+    };
+    // 根据不同的 scope 类型设置相应的参数
+    switch (scopeType) {
+        case 'ALL':
+            // 导出全部不需要额外参数
+            break;
+        case 'SELECTED_ENDPOINTS':
+            body.scope.selectedEndpointIds = selectedEndpointIds;
+            break;
+        case 'SELECTED_TAGS':
+            body.scope.selectedTags = selectedTags;
+            break;
+        case 'SELECTED_FOLDERS':
+            body.scope.selectedFolderIds = selectedFolderIds;
+            break;
+    }
+    return {
+        name: constant_1.PluginName.APIFOX,
+        config({ config }) {
+            const base = 'https://api.apifox.com/v1/projects';
+            if (projectId && apifoxToken) {
+                config.input = `${base}/${encodeURIComponent(projectId)}/export-openapi?locale=${encodeURIComponent(locale)}`;
+                config.fetchOptions = {
+                    ...config.fetchOptions,
+                    headers: {
+                        'X-Apifox-Api-Version': apifoxVersion,
+                        'Authorization': `Bearer ${apifoxToken}`,
+                    },
+                    method: 'POST',
+                    data: body,
+                };
+            }
+            return config;
+        },
+    };
+}
+exports.default = apifox;

package/dist/plugins/presets/filterApi.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterApiDescriptor = filterApiDescriptor;
+exports.apiFilter = apiFilter;
+const constant_1 = require("../../constant");
+const logger_1 = require("../../helper/logger");
+const utils_1 = require("./utils");
+/**
+ * Tests if value matches the specified rule
+ */
+function isMatch(value, match) {
+    if (!match)
+        return true;
+    if (typeof match === 'string') {
+        return value.includes(match);
+    }
+    if (match instanceof RegExp) {
+        return match.test(value);
+    }
+    if (typeof match === 'function') {
+        try {
+            return match(value);
+        }
+        catch {
+            return false; // Return false on error to exclude the item
+        }
+    }
+    return false;
+}
+/**
+ * Extracts the corresponding property value from API descriptor based on scope
+ */
+function getApiProperty(apiDescriptor, scope) {
+    switch (scope) {
+        case constant_1.FilterScope.URL:
+            return apiDescriptor.url || '';
+        case constant_1.FilterScope.TAG:
+            // Assume tags exist in tags array, join with comma if multiple tags
+            return Array.isArray(apiDescriptor.tags) ? apiDescriptor.tags.join(',') : '';
+        default:
+            return '';
+    }
+}
+/**
+ * Applies filtering rules for a single configuration
+ * @param apiDescriptor API descriptor
+ * @param config Filter configuration
+ * @returns Whether it passes the filter (true means keep, false means filter out)
+ */
+function applyFilterRule(apiDescriptor, config) {
+    const scope = config.scope || constant_1.FilterScope.URL;
+    const value = getApiProperty(apiDescriptor, scope);
+    // Handle include and exclude logic
+    const includeMatch = config.include ? isMatch(value, config.include) : true;
+    const excludeMatch = config.exclude ? isMatch(value, config.exclude) : false;
+    // If both include and exclude are specified, exclude matching items from include
+    return includeMatch && !excludeMatch;
+}
+/**
+ * Handles union logic for multiple configurations
+ * @param apiDescriptor API descriptor
+ * @param configs Configuration array
+ * @returns Whether it passes the filter (true means keep, false means filter out)
+ */
+function combineFilterResults(apiDescriptor, configs) {
+    // If any configuration matches, keep the API (union logic)
+    return configs.some(config => applyFilterRule(apiDescriptor, config));
+}
+/**
+ * Main processing function for filtering API descriptors
+ * @param apiDescriptor API descriptor
+ * @param configs Configuration array
+ * @returns Filtered API descriptor, or null if filtered out
+ */
+function filterApiDescriptor(apiDescriptor, configs) {
+    if (!apiDescriptor)
+        return null;
+    // Use union logic to determine whether to keep the API
+    const shouldKeep = combineFilterResults(apiDescriptor, configs);
+    return shouldKeep ? apiDescriptor : null;
+}
+/**
+ * Creates a plugin for filtering APIs
+ *
+ * @param config Filter configuration, can be a single config or array of configs
+ * @returns API plugin instance
+ *
+ * @example
+ * ```ts
+ * // Only include URLs containing 'user'
+ * const userOnlyFilter = apiFilter({
+ *   include: 'user'
+ * });
+ *
+ * // Exclude tags containing 'internal'
+ * const noInternalFilter = apiFilter({
+ *   scope: 'tag',
+ *   exclude: 'internal'
+ * });
+ *
+ * // Multi-condition filtering (union)
+ * const multiFilter = apiFilter([
+ *   { include: 'user' },
+ *   { include: 'admin' }
+ * ]);
+ * ```
+ */
+function apiFilter(config) {
+    const configs = Array.isArray(config) ? config : [config];
+    // Validate configuration
+    for (const conf of configs) {
+        if (!conf.include && !conf.exclude) {
+            throw logger_1.logger.throwError('at least one of `include` or `exclude` must be specified');
+        }
+    }
+    return {
+        name: constant_1.PluginName.FILTER_API,
+        config({ config }) {
+            return (0, utils_1.extend)(config, {
+                handleApi: (apiDescriptor) => {
+                    if (!apiDescriptor)
+                        return null;
+                    return filterApiDescriptor(apiDescriptor, configs);
+                },
+            });
+        },
+    };
+}
+exports.default = apiFilter;

package/dist/plugins/presets/importType.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importType = importType;
+const constant_1 = require("../../constant");
+// Reusable helper: insert text after leading block comment(s) at file top
+const LEADING_BLOCK_COMMENTS = /^\s*(?:\/\*[\s\S]*?\*\/\s*)+/;
+function insertAfterLeadingBlockComments(content, insertion) {
+    const match = content.match(LEADING_BLOCK_COMMENTS);
+    const insertAt = match ? match[0].length : 0;
+    if (insertAt === 0) {
+        return `${insertion}\n${content}`;
+    }
+    const prefix = content.slice(0, insertAt);
+    const suffix = content.slice(insertAt);
+    const safePrefix = prefix.endsWith('\n') ? prefix : `${prefix}\n`;
+    return `${safePrefix}${insertion}\n${suffix}`;
+}
+function importType(imports, options) {
+    const entries = Object.entries(imports);
+    const excludedTypeNames = Array.from(new Set(entries.flatMap(([, names]) => names)));
+    const targetFiles = options?.files ?? ['globals.d'];
+    const importLines = entries
+        .map(([key, names]) => {
+        const [specifier, ...flags] = key.split('|');
+        const isTypeImport = flags.includes('type');
+        const kw = isTypeImport ? 'import type' : 'import';
+        const named = names.join(', ');
+        return `${kw} { ${named} } from '${specifier}'`;
+    })
+        .join('\n');
+    return {
+        name: constant_1.PluginName.IMPORT_TYPE,
+        config({ config: cfg }) {
+            cfg.externalTypes = Array.from(new Set([...(cfg.externalTypes ?? []), ...excludedTypeNames]));
+            return cfg;
+        },
+        // 9.1.2: Use beforeFileWrite to modify individual file content before write
+        beforeFileWrite({ filePath, content }) {
+            if (entries.length === 0)
+                return content;
+            const matched = targetFiles.some(target => filePath.includes(target));
+            if (matched) {
+                return insertAfterLeadingBlockComments(content, importLines);
+            }
+            return content;
+        },
+    };
+}
+exports.default = importType;

package/dist/plugins/presets/payloadModifier/hepler.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyModifierSchema = applyModifierSchema;
+// Convert Schema (custom spec) -> OpenAPI SchemaObject
+function toSchemaObject(base, s) {
+    const result = { ...base };
+    const cleanType = (schema) => {
+        delete schema.type;
+        delete schema.enum;
+        delete schema.oneOf;
+        delete schema.anyOf;
+        delete schema.allOf;
+        delete schema.items;
+        delete schema.properties;
+        delete schema.required;
+        return schema;
+    };
+    // Legacy union as array (treated as oneOf)
+    if (Array.isArray(s)) {
+        const baseOneOf = base.oneOf || [];
+        cleanType(result);
+        result.oneOf = s.map((item, idx) => toSchemaObject(baseOneOf[idx] || {}, item));
+        return result;
+    }
+    // Primitive types and no-op primitives
+    if (typeof s === 'string') {
+        result.type = s;
+        return result;
+    }
+    // Handle union keywords: overwrite arrays but preserve unrelated fields
+    if (s.oneOf) {
+        const spec = s;
+        const baseOneOf = base.oneOf || [];
+        cleanType(result);
+        result.oneOf = spec.oneOf.map((item, idx) => toSchemaObject(baseOneOf[idx] || {}, item));
+    }
+    if (s.anyOf) {
+        const spec = s;
+        const baseAnyOf = base.anyOf || [];
+        cleanType(result);
+        result.anyOf = spec.anyOf.map((item, idx) => toSchemaObject(baseAnyOf[idx] || {}, item));
+    }
+    if (s.allOf) {
+        const spec = s;
+        const baseAllOf = base.allOf || [];
+        cleanType(result);
+        result.allOf = spec.allOf.map((item, idx) => toSchemaObject(baseAllOf[idx] || {}, item));
+    }
+    // Enum: set enum and optional type
+    if (s.enum) {
+        const spec = s;
+        result.enum = spec.enum;
+        if (spec.type) {
+            result.type = spec.type;
+        }
+    }
+    // Array: set/merge items
+    if (s.type === 'array') {
+        const spec = s;
+        result.type = 'array';
+        const baseItems = result.items;
+        if (Array.isArray(spec.items)) {
+            // Tuple items: replace entire items with tuple
+            const items = spec.items.map(item => toSchemaObject({}, item));
+            result.items = items;
+        }
+        else {
+            // Single items: merge into existing items schema
+            const patchItem = toSchemaObject(typeof baseItems === 'object' ? baseItems : {}, spec.items);
+            result.items = patchItem;
+        }
+        return result;
+    }
+    // Object (reference-like map): merge properties and required
+    const ref = s;
+    if (ref && typeof ref === 'object') {
+        result.type = 'object';
+        const properties = { ...result.properties };
+        const requiredSet = new Set(Array.isArray(result.required) ? result.required : []);
+        for (const key in ref) {
+            const val = ref[key];
+            if (!val) {
+                continue;
+            }
+            const optional = key.endsWith('?');
+            const cleanKey = optional ? key.slice(0, -1) : key;
+            const baseProp = properties[cleanKey];
+            properties[cleanKey] = toSchemaObject(baseProp || {}, val);
+            if (optional) {
+                requiredSet.delete(cleanKey);
+            }
+            else {
+                requiredSet.add(cleanKey);
+            }
+        }
+        result.properties = properties;
+        result.required = Array.from(requiredSet);
+        return result;
+    }
+    return result;
+}
+function schemaTypeToPrimitiveType(t) {
+    if (t === null) {
+        return 'null';
+    }
+    if (t === undefined) {
+        return 'undefined';
+    }
+    if (!t) {
+        return 'unknown';
+    }
+    if (t === 'integer') {
+        return 'number';
+    }
+    return t;
+}
+// Convert existing OpenAPI SchemaObject -> Schema (best-effort, for handler input)
+function toSchemaSpec(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return 'unknown';
+    }
+    // Union keywords
+    if (Array.isArray(obj.oneOf)) {
+        const arr = obj.oneOf;
+        return { oneOf: arr.map(item => toSchemaSpec(item)) };
+    }
+    if (Array.isArray(obj.anyOf)) {
+        const arr = obj.anyOf;
+        return { anyOf: arr.map(item => toSchemaSpec(item)) };
+    }
+    if (Array.isArray(obj.allOf)) {
+        const arr = obj.allOf;
+        return { allOf: arr.map(item => toSchemaSpec(item)) };
+    }
+    // Enum
+    if (Array.isArray(obj.enum) && obj.enum.length > 0) {
+        const type = typeof obj.type === 'string' ? obj.type : undefined;
+        return { enum: obj.enum, type };
+    }
+    // Array
+    if (obj.type === 'array' || obj.items) {
+        const items = obj.items;
+        if (Array.isArray(items)) {
+            return { type: 'array', items: items.map((it) => toSchemaSpec(it)) };
+        }
+        if (items) {
+            return { type: 'array', items: toSchemaSpec(items) };
+        }
+        return { type: 'array', items: 'unknown' };
+    }
+    // Object
+    if (obj.type === 'object' || obj.properties) {
+        const properties = obj.properties || {};
+        const requiredSet = new Set(Array.isArray(obj.required) ? obj.required : []);
+        const result = {};
+        for (const key of Object.keys(properties)) {
+            const spec = toSchemaSpec(properties[key]);
+            const finalKey = requiredSet.has(key) ? key : `${key}?`;
+            result[finalKey] = spec;
+        }
+        return result;
+    }
+    // type union as array
+    if (Array.isArray(obj.type)) {
+        const typeArr = obj.type;
+        const mapped = typeArr.map(schemaTypeToPrimitiveType);
+        return { oneOf: mapped };
+    }
+    return schemaTypeToPrimitiveType(obj.type);
+}
+// Replace whole schema based on handler result (used for params/pathParams)
+function applyModifierSchema(schema, config, { required }) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    const cloned = { ...schema };
+    const currentSpec = toSchemaSpec(cloned);
+    const ret = config.handler(currentSpec);
+    if (!ret) {
+        return {
+            required,
+            value: null,
+        };
+    }
+    if (typeof ret === 'object' && 'required' in ret && 'value' in ret) {
+        return {
+            required: !!(ret.required ?? required),
+            value: toSchemaObject(cloned, ret.value),
+        };
+    }
+    return {
+        required,
+        value: toSchemaObject(cloned, ret),
+    };
+}