datagrok-tools 4.14.69 → 4.14.71

package/bin/commands/check.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.check = check;
 exports.checkChangelog = checkChangelog;
+exports.checkDatagrokApiImports = checkDatagrokApiImports;
 exports.checkFuncSignatures = checkFuncSignatures;
 exports.checkImportStatements = checkImportStatements;
 exports.checkNpmIgnore = checkNpmIgnore;
@@ -18,6 +19,8 @@ var _ignoreWalk = _interopRequireDefault(require("ignore-walk"));
 var utils = _interopRequireWildcard(require("../utils/utils"));
 var color = _interopRequireWildcard(require("../utils/color-utils"));
 var testUtils = _interopRequireWildcard(require("../utils/test-utils"));
+var _const = require("datagrok-api/src/const");
+var _child_process = require("child_process");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const warns = ['Latest package version', 'Datagrok API version should contain'];
 const forbiddenNames = ['function', 'class', 'export'];
@@ -33,7 +36,7 @@ function check(args) {
     return runChecks(curDir, args.soft ?? false);
   }
 }
-function runChecks(packagePath, soft = false) {
+function runChecks(packagePath, soft = false, noExit = false) {
   if (packagePath.includes(`${_path.default.sep}node_modules${_path.default.sep}`)) return true;
   const files = _ignoreWalk.default.sync({
     path: packagePath,
@@ -50,8 +53,12 @@ function runChecks(packagePath, soft = false) {
   }));
   const webpackConfigPath = _path.default.join(packagePath, 'webpack.config.js');
   const isWebpack = _fs.default.existsSync(webpackConfigPath);
+  const semver = json.version.split('-')[0];
+  const [major, minor, patch] = semver.split('.').map(Number);
+  let isPre1Version = false;
   let isReleaseCandidateVersion = false;
   let externals = null;
+  if (major === 0) isPre1Version = true;
   if (/\d+.\d+.\d+-rc(.[A-Za-z0-9]*.[A-Za-z0-9]*)?/.test(json.version)) isReleaseCandidateVersion = true;
   if (isWebpack) {
     const content = _fs.default.readFileSync(webpackConfigPath, {
@@ -60,6 +67,7 @@ function runChecks(packagePath, soft = false) {
     externals = extractExternals(content);
     if (externals) errors.push(...checkImportStatements(packagePath, jsTsFiles, externals));
   }
+  errors.push(...checkDatagrokApiImports(packagePath, jsTsFiles));
   if (!soft) errors.push(...checkSourceMap(packagePath));
   errors.push(...checkNpmIgnore(packagePath));
   warnings.push(...checkScriptNames(packagePath));
@@ -71,7 +79,7 @@ function runChecks(packagePath, soft = false) {
     externals,
     isReleaseCandidateVersion
   }));
-  if (!isReleaseCandidateVersion) warnings.push(...checkChangelog(packagePath, json));
+  if (!isReleaseCandidateVersion && !isPre1Version) warnings.push(...checkChangelog(packagePath, json));
   if (warnings.length) {
     console.log(`${_path.default.basename(packagePath)} warnings`);
     warn(warnings);
@@ -80,23 +88,30 @@ function runChecks(packagePath, soft = false) {
     console.log(`Checking package ${_path.default.basename(packagePath)}...`);
     showError(errors);
     if (soft || json.version.startsWith('0') || errors.every(w => warns.some(ww => w.includes(ww)))) return true;
-    testUtils.exitWithCode(1);
+    if (noExit) return false;else testUtils.exitWithCode(1);
   }
   console.log(`Checking package ${_path.default.basename(packagePath)}...\t\t\t\u2713 OK`);
   return true;
 }
 function runChecksRec(dir, soft = false) {
   const files = _fs.default.readdirSync(dir);
+  let allPassed = true;
   for (const file of files) {
     const filepath = _path.default.join(dir, file);
     const stats = _fs.default.statSync(filepath);
     if (stats.isDirectory()) {
-      if (utils.isPackageDir(filepath)) return runChecks(filepath, soft);else {
-        if (file !== 'node_modules' && !file.startsWith('.')) runChecksRec(_path.default.join(dir, file), soft);
+      if (utils.isPackageDir(filepath)) {
+        const passed = runChecks(filepath, soft, true);
+        allPassed = allPassed && passed;
+      } else {
+        if (file !== 'node_modules' && !file.startsWith('.')) {
+          const passed = runChecksRec(_path.default.join(dir, file), soft);
+          allPassed = allPassed && passed;
+        }
       }
     }
   }
-  return false;
+  return allPassed;
 }
 function extractExternals(config) {
   const externalsRegex = /(?<=externals)\s*:\s*(\{[\S\s]*?\})/;
@@ -144,197 +159,174 @@ function checkImportStatements(packagePath, files, externals) {
   }
   return warnings;
 }
-function checkFuncSignatures(packagePath, files) {
-  const warnings = [];
+function checkDatagrokApiImports(packagePath, files) {
   const errors = [];
-  const checkFunctions = {
-    app: ({
-      name
-    }) => {
-      let value = true;
-      let message = '';
-      if (name && typeof name === 'string') {
-        const lowerCaseName = name.toLocaleLowerCase();
-        if (lowerCaseName.startsWith('app')) {
-          value = false;
-          message += 'Prefix "App" is not needed. Consider removing it.\n';
-        }
-        if (lowerCaseName.endsWith('app')) {
-          value = false;
-          message += 'Postfix "App" is not needed. Consider removing it.\n';
-        }
-      }
-      return {
-        value,
-        message
-      };
-    },
-    semTypeDetector: ({
-      inputs,
-      outputs
-    }) => {
-      let value = true;
-      let message = '';
-      if (inputs.length !== 1 || inputs[0].type !== 'column') {
-        value = false;
-        message += 'Semantic type detectors must have one input of type "column"\n';
-      }
-      if (outputs.length !== 1 || outputs[0].type !== 'string') {
-        value = false;
-        message += 'Semantic type detectors must have one output of type "string"\n';
-      }
-      return {
-        value,
-        message
-      };
-    },
-    cellRenderer: ({
-      inputs,
-      outputs
-    }) => {
-      let value = true;
-      let message = '';
-      if (inputs.length !== 0) {
-        value = false;
-        message += 'Cell renderer functions should take no arguments\n';
-      }
-      if (outputs.length !== 1 || outputs[0].type !== 'grid_cell_renderer') {
-        value = false;
-        message += 'Cell renderer functions must have one output of type "grid_cell_renderer"\n';
-      }
-      return {
-        value,
-        message
-      };
-    },
-    viewer: ({
-      inputs,
-      outputs
-    }) => {
-      let value = true;
-      let message = '';
-      if (inputs.length !== 0) {
-        value = false;
-        message += 'Viewer functions should take no arguments\n';
-      }
-      if (outputs.length > 1 || outputs.length === 1 && outputs[0].type !== 'viewer') {
-        value = false;
-        message += 'Viewers must have one output of type "viewer"\n';
-      }
-      return {
-        value,
-        message
-      };
-    },
-    fileViewer: ({
-      inputs,
-      outputs,
-      tags
-    }) => {
-      let value = true;
-      let message = '';
-      if (tags == null || tags.length !== 1 && tags[0] !== 'fileViewer') {
-        value = false;
-        message += 'File viewers must have only one tag: "fileViewer"\n';
-      }
-      if (inputs.length !== 1 || inputs[0].type !== 'file') {
-        value = false;
-        message += 'File viewers must have one input of type "file"\n';
-      }
-      if (outputs.length !== 1 || outputs[0].type !== 'view') {
-        value = false;
-        message += 'File viewers must have one output of type "view"\n';
-      }
-      return {
-        value,
-        message
-      };
-    },
-    fileExporter: ({
-      description
-    }) => {
-      let value = true;
-      let message = '';
-      if (description == null || description === '') {
-        value = false;
-        message += 'File exporters should have a description parameter\n';
-      }
-      return {
-        value,
-        message
-      };
-    },
-    packageSettingsEditor: ({
-      outputs
-    }) => {
-      let value = true;
-      let message = '';
-      if (!(outputs.length === 1 && outputs[0].type === 'widget')) {
-        value = false;
-        message += 'Package settings editors must have one output of type "widget"\n';
-      }
-      return {
-        value,
-        message
-      };
-    },
-    params: ({
-      inputs,
-      outputs
-    }) => {
-      let value = true;
-      let message = '';
-      for (const input of inputs) {
-        if (!(input.name && input.type)) {
-          value = false;
-          message += `Function has no name or type of input parameter\n`;
+
+  // Regex to find all datagrok-api imports/exports (including re-exports)
+  const datagrokApiImportRegex = /^\s*(import|export)\s+.*['"]datagrok-api\/[^'"]+['"]/gm;
+
+  // Regex to validate if import/export is allowed (only dg, grok, ui)
+  const allowedImportRegex = /^\s*(import|export)\s+.*['"]datagrok-api\/(dg|grok|ui)['"]/;
+
+  // Regex to extract the import path for error messages
+  const importPathRegex = /['"]datagrok-api\/([^'"]+)['"]/;
+  for (const file of files) {
+    const content = _fs.default.readFileSync(_path.default.join(packagePath, file), {
+      encoding: 'utf-8'
+    });
+    const matchedImports = content.match(datagrokApiImportRegex);
+    if (matchedImports) {
+      for (const match of matchedImports) {
+        // Check if this import/export is allowed
+        if (!allowedImportRegex.test(match)) {
+          // Extract the problematic path for error message
+          const pathMatch = match.match(importPathRegex);
+          const importedPath = pathMatch ? `datagrok-api/${pathMatch[1]}` : 'unknown';
+          errors.push(`File "${file}": Invalid datagrok-api import.
+` + `  Found: ${match.trim()}
+` + `  Only these paths are allowed: 'datagrok-api/dg', 'datagrok-api/grok', 'datagrok-api/ui'
+` + `  Deep imports like '${importedPath}' are not permitted.`);
         }
       }
-      for (const output of outputs) {
-        if (!(output.name && output.type)) {
-          value = false;
-          message += `Function has no name or type of output parameter\n`;
-        }
+    }
+  }
+  return errors;
+}
+const TYPE_ALIASES = {
+  file: ['fileinfo'],
+  dynamic: ['searchprovider']
+};
+function normalizeType(type) {
+  return type.toLowerCase().replace(/_/g, '');
+}
+function typesMatch(actual, expected) {
+  const a = normalizeType(actual);
+  const e = normalizeType(expected);
+  if (a === e) return true;
+  const aliases = TYPE_ALIASES[a];
+  return aliases ? aliases.includes(e) : false;
+}
+function parseSignature(sig) {
+  const match = sig.match(/^[^(]+\(([^)]*)\)\s*:\s*(.+)$/);
+  if (!match) throw new Error(`Invalid signature format: ${sig}`);
+  const paramsStr = match[1].trim();
+  const returnTypeStr = match[2].trim();
+  let variadicIndex = -1;
+  const parseParam = (p, index) => {
+    const trimmed = p.trim();
+    const isVariadic = trimmed.startsWith('...');
+    if (isVariadic) variadicIndex = index;
+    const paramBody = isVariadic ? trimmed.slice(3) : trimmed;
+    const [name, type] = paramBody.split(':').map(s => s.trim());
+    return {
+      name,
+      type: type || 'any'
+    };
+  };
+  const inputs = paramsStr ? paramsStr.split(',').map((p, i) => parseParam(p, i)) : [];
+  const outputs = returnTypeStr ? returnTypeStr.split('|').map(t => ({
+    name: '',
+    type: t.trim()
+  })) : [];
+  return {
+    inputs,
+    outputs,
+    variadicIndex
+  };
+}
+function validateFunctionSignature(func, roleDesc) {
+  let valid = true;
+  const messages = [];
+  const addError = msg => {
+    valid = false;
+    messages.push(msg);
+  };
+  const normalize = t => t?.toLowerCase();
+  const fmtParam = p => p ? `${p.name ?? '<unnamed>'}: ${p.type ?? '<unknown>'}` : '<missing>';
+  const fmtTypes = types => types.join(' | ');
+  const matchesExpected = (actual, expected) => {
+    if (!actual || !expected) return false;
+    const actualType = normalize(actual);
+    const expectedTypes = expected.split('|').map(t => normalize(t.trim()));
+    return expectedTypes.some(t => t === 'any' || typesMatch(actualType, t));
+  };
+  if (roleDesc.role === 'app' && func.name) {
+    const name = func.name.toLowerCase();
+    if (name.startsWith('app')) addError('Prefix "App" is not needed. Consider removing it.');
+    if (name.endsWith('app')) addError('Postfix "App" is not needed. Consider removing it.');
+  }
+  if (roleDesc.role === 'fileExporter' && (!func.description || func.description === '')) addError('File exporters should have a description parameter');
+  if (roleDesc.role === 'fileViewer') {
+    const hasFileViewerTag = func.tags?.length === 1 && func.tags[0] === 'fileViewer';
+    const hasFileViewerRole = func.meta?.role === 'fileViewer';
+    if (!(hasFileViewerTag || hasFileViewerRole)) addError('File viewers must have only one tag: "fileViewer"');
+  }
+  const parsed = parseSignature(roleDesc.signature);
+  const maxInputs = parsed.variadicIndex >= 0 ? parsed.variadicIndex : parsed.inputs.length;
+  for (let i = 0; i < maxInputs; i++) {
+    const expected = parsed.inputs[i];
+    const actual = func.inputs[i];
+    if (!actual) {
+      addError(`Input ${i} missing: expected ${fmtParam(expected)}`);
+      continue;
+    }
+    if (!matchesExpected(actual.type, expected?.type)) addError(`Input ${i} mismatch: expected ${fmtTypes(expected?.type?.split('|').map(t => t.trim()) ?? [])}, got ${actual.type}`);
+  }
+  if (parsed.outputs.length > 0) {
+    if (!func.outputs?.length) {
+      if (!parsed.outputs.some(o => o.type === 'void')) addError(`Output missing: expected one of (${fmtTypes(parsed.outputs.map(o => o.type))})`);
+    } else {
+      const matches = func.outputs.some(actual => parsed.outputs.some(expected => matchesExpected(actual.type, expected.type)));
+      if (!matches) {
+        addError(`Output mismatch: expected one of (${fmtTypes(parsed.outputs.map(o => o.type))}),
+          got (${fmtTypes(func.outputs.map(o => o.type))})`);
       }
-      return {
-        value,
-        message
-      };
     }
+  }
+  [...func.inputs, ...(func.outputs ?? [])].forEach((p, i) => {
+    if (!p.name || !p.type) addError(`Parameter ${i} is incomplete: name=${p.name ?? '<missing>'}, type=${p.type ?? '<missing>'}`);
+  });
+  return {
+    value: valid,
+    message: messages.join('\n')
   };
-  const functionRoles = Object.keys(checkFunctions);
+}
+function checkFuncSignatures(packagePath, files) {
+  const warnings = [];
+  const errors = [];
+  const namesInFiles = new Map();
+  const roleMap = new Map(_const.functionRoles.map(r => [r.role, r]));
   for (const file of files) {
     if (file.includes('.min.')) continue;
-    const content = _fs.default.readFileSync(_path.default.join(packagePath, file), {
-      encoding: 'utf-8'
-    });
+    const content = _fs.default.readFileSync(_path.default.join(packagePath, file), 'utf-8');
     const functions = getFuncMetadata(content, file.split('.').pop() ?? 'ts');
     for (const f of functions.meta) {
-      const paramsCheck = checkFunctions.params(f);
-      if (!paramsCheck.value) warnings.push(`File ${file}, function ${f.name}:\n${paramsCheck.message}`);
-      const roles = functionRoles.filter(role => f.tags?.includes(role));
-      if (roles.length > 1) warnings.push(`File ${file}, function ${f.name}: several function roles are used (${roles.join(', ')})`);else if (roles.length === 1) {
-        const vr = checkFunctions[roles[0]](f);
-        if (!vr.value) {
-          warnings.push(`File ${file}, function ${f.name}:\n${vr.message}`);
-        }
+      const allRoles = new Set([...(f.tags ?? []), ...(f.meta?.role?.split(',').map(r => r.trim()) ?? [])]);
+      const roles = [...allRoles].filter(r => roleMap.has(r));
+      for (const role of roles) {
+        const roleDesc = roleMap.get(role);
+        const vr = validateFunctionSignature(f, roleDesc);
+        if (!vr.value) warnings.push(`File ${file}, function ${f.name}:\n${vr.message}`);
       }
-      let wrongInputNames = f.inputs.filter(e => forbiddenNames.includes(e?.name ?? ''));
+      const invalidNames = f.inputs.filter(e => forbiddenNames.includes(e?.name ?? ''));
+      if (invalidNames.length) errors.push(`File ${file}, function ${f.name}: Wrong input names: (${invalidNames.map(e => e.name).join(', ')})`);
       if (f.name && f.name !== 'postprocess') {
-        if (namesInFiles.has(f.name)) namesInFiles.get(f.name)?.push(file);else namesInFiles.set(f.name, [file]);
+        if (!namesInFiles.has(f.name)) namesInFiles.set(f.name, []);
+        namesInFiles.get(f.name).push(file);
       }
-      if (wrongInputNames.length > 0) errors.push(`File ${file}, function ${f.name}: Wrong input names: (${wrongInputNames.map(e => e.name).join(', ')})`);
-      if (f.isInvalidateOnWithoutCache) errors.push(`File ${file}, function ${f.name}: Can't use invalidateOn without cache, please follow this example: 'meta.cache.invalidateOn'`);
-      if (f.cache) if (!utils.cacheValues.includes(f.cache)) errors.push(`File ${file}, function ${f.name}: unsupposed variable for cache : ${f.cache}`);
-      if (f.invalidateOn) if (!utils.isValidCron(f.invalidateOn)) errors.push(`File ${file}, function ${f.name}: unsupposed variable for invalidateOn : ${f.invalidateOn}`);
+      if (f.isInvalidateOnWithoutCache) errors.push(`File ${file}, function ${f.name}: Can't use invalidateOn without cache`);
+      if (f.cache && !utils.cacheValues.includes(f.cache)) errors.push(`File ${file}, function ${f.name}: unsupported cache variable: ${f.cache}`);
+      if (f.invalidateOn && !utils.isValidCron(f.invalidateOn)) errors.push(`File ${file}, function ${f.name}: unsupported invalidateOn: ${f.invalidateOn}`);
     }
-    functions.warnings.forEach(e => {
-      warnings.push(`${e} In the file: ${file}.`);
-    });
-  }
-  for (const [name, files] of namesInFiles) {
-    if (files.length > 1) errors.push(`Duplicate names ('${name}'): \n  ${files.join('\n  ')}`);
+    functions.warnings.forEach(w => warnings.push(`${w} In the file: ${file}.`));
   }
+
+  // Temporarily skip name-checking logic, as duplicate names are allowed
+  // for (const [name, files] of namesInFiles) {
+  //   if (files.length > 1)
+  //     errors.push(`Duplicate names ('${name}'): \n  ${files.join('\n  ')}`);
+  // }
+
   return [warnings, errors];
 }
 const sharedLibExternals = {
@@ -405,14 +397,14 @@ function checkPackageFile(packagePath, json, options) {
   }
   if (options?.isReleaseCandidateVersion === true) {
     let hasRCDependency = false;
-    for (let dependency of Object.keys(json.dependencies ?? {})) {
+    for (const dependency of Object.keys(json.dependencies ?? {})) {
       if (/\d+.\d+.\d+-rc(.[A-Za-z0-9]*.[A-Za-z0-9]*)?/.test((json.dependencies ?? {})[dependency])) {
         hasRCDependency = true;
         break;
       }
     }
     if (!hasRCDependency) {
-      for (let dependency of Object.keys(json.dependencies ?? {})) {
+      for (const dependency of Object.keys(json.dependencies ?? {})) {
         if (/\d+.\d+.\d+-rc(.[A-Za-z0-9]*.[A-Za-z0-9]*)?/.test((json.devDependencies ?? {})[dependency])) {
           hasRCDependency = true;
           break;
@@ -463,8 +455,27 @@ function checkSourceMap(packagePath) {
     }); // cant convert to json because file contains comments
 
     if (!new RegExp(`devtool\\s*:\\s*(([^\\n]*?[^\\n]*source-map[^\\n]*:[^\\n]*source-map[^\\n]*)|('(inline-)?source-map'))\\s*`).test(webpackConfigJson)) warnings.push('webpack config doesnt contain source map');
-    if (!_fs.default.existsSync(packagePath + '/dist/package.js')) warnings.push('dist\\package.js file doesnt exists');
-    if (!_fs.default.existsSync(packagePath + '/dist/package-test.js')) warnings.push('dist\\package-test.js file doesnt exists');
+
+    // Check if dist files exist
+    const distPackage = _path.default.join(packagePath, 'dist', 'package.js');
+    const distPackageTest = _path.default.join(packagePath, 'dist', 'package-test.js');
+    let missingFiles = [distPackage, distPackageTest].filter(f => !_fs.default.existsSync(f));
+
+    // If any dist files are missing, try to build automatically
+    if (missingFiles.length > 0) {
+      try {
+        (0, _child_process.execSync)('npm run build', {
+          cwd: packagePath,
+          stdio: 'inherit'
+        });
+      } catch (e) {
+        console.warn('Build failed:', e);
+      }
+
+      // Recheck dist files after build
+      missingFiles = [distPackage, distPackageTest].filter(f => !_fs.default.existsSync(f));
+      missingFiles.forEach(f => warnings.push(`${_path.default.relative(packagePath, f)} file doesnt exist even after build`));
+    }
   }
   return warnings;
 }
@@ -502,9 +513,7 @@ function getAllFilesInDirectory(directoryPath) {
   entries.forEach(entry => {
     const entryPath = _path.default.join(directoryPath, entry);
     const stat = _fs.default.statSync(entryPath);
-    if (stat.isFile()) {
-      fileNames.push(entry);
-    } else if (stat.isDirectory() && !excludedFilesToCheck.includes(entry)) {
+    if (stat.isFile()) fileNames.push(entry);else if (stat.isDirectory() && !excludedFilesToCheck.includes(entry)) {
       const subDirectoryFiles = getAllFilesInDirectory(entryPath);
       fileNames = fileNames.concat(subDirectoryFiles);
     }
@@ -517,66 +526,94 @@ function showError(errors) {
 function warn(warnings) {
   warnings.forEach(w => color.warn(w));
 }
-function getFuncMetadata(script, fileExtention) {
+function getFuncMetadata(script, fileExtension) {
   const funcData = [];
   const warnings = [];
-  let isHeader = false;
-  let data = {
-    name: '',
-    inputs: [],
-    outputs: []
-  };
-  for (const line of script.split('\n')) {
-    if (!line) continue;
-    //@ts-ignore
-    const match = line.match(utils.fileParamRegex[fileExtention]);
-    if (match) {
-      if (!isHeader) isHeader = true;
+  const lines = script.split('\n');
+  const funcStartRegex = /^\s*function\s+\w+\s*\(|^\s*(export\s+)?(async\s+)?function\s+\w+\s*\(|^\s*(export\s+)?(const|let)\s+\w+\s*=\s*\(.*\)\s*=>/;
+  function parseHeaderLines(headerLines) {
+    const data = {
+      name: '',
+      inputs: [],
+      outputs: []
+    };
+    let hasContent = false;
+    for (const headerLine of headerLines) {
+      const match = headerLine.match(utils.fileParamRegex[fileExtension]);
+      if (!match) continue;
       const param = match[1];
-      if (!utils.headerTags.includes(param) && !param.includes('meta.')) {
-        warnings.push(`Unknown header tag: ${param},`);
+      if (!utils.headerTags.includes(param) && !param.startsWith('meta.')) {
+        warnings.push(`Unknown header tag: ${param}`);
         continue;
       }
-      if (param === 'name') data.name = line.match(utils.nameAnnRegex)?.[2]?.toLocaleLowerCase();else if (param === 'description') data.description = match[2];else if (param === 'input') {
-        data.inputs.push({
-          type: match[2],
-          name: match[3]
-        });
-      } else if (param === 'output') data.outputs.push({
-        type: match[2],
-        name: match[3]
-      });else if (param === 'tags') {
-        data.tags = match.input && match[3] ? match.input.split(':')[1].split(',').map(t => t.trim()) : [match[2]];
-      } else if (param === 'meta.cache') {
-        data.cache = line.split(':').pop()?.trim();
-      } else if (param === 'meta.cache.invalidateOn') {
-        data.invalidateOn = line.split(':').pop()?.trim();
-      } else if (param === 'meta.invalidateOn') {
-        data.isInvalidateOnWithoutCache = true;
+      switch (param) {
+        case 'name':
+          data.name = headerLine.match(utils.nameAnnRegex)?.[2]?.toLocaleLowerCase() || '';
+          hasContent = true;
+          break;
+        case 'description':
+          data.description = match[2];
+          hasContent = true;
+          break;
+        case 'input':
+          data.inputs.push({
+            type: match[2],
+            name: match[3]
+          });
+          hasContent = true;
+          break;
+        case 'output':
+          data.outputs.push({
+            type: match[2],
+            name: match[3]
+          });
+          hasContent = true;
+          break;
+        case 'tags':
+          data.tags = match.input && match[3] ? match.input.split(':')[1].split(',').map(t => t.trim()) : [match[2]];
+          hasContent = true;
+          break;
+        case 'meta.role':
+          data.meta = data.meta || {};
+          data.meta.role = match[2];
+          hasContent = true;
+          break;
+        case 'meta.cache':
+          data.cache = headerLine.split(':').pop()?.trim();
+          hasContent = true;
+          break;
+        case 'meta.cache.invalidateOn':
+          data.invalidateOn = headerLine.split(':').pop()?.trim();
+          hasContent = true;
+          break;
+        case 'meta.invalidateOn':
+          data.isInvalidateOnWithoutCache = true;
+          hasContent = true;
+          break;
       }
     }
-    if (isHeader) {
-      const nm = line.match(utils.nameRegex);
-      if (data.name === '') {
-        data = {
-          name: '',
-          inputs: [],
-          outputs: []
-        };
-        isHeader = false;
-        continue;
-      }
-      if (nm) data.name = nm[1]?.toLocaleLowerCase();
-      if (data.name && !match) {
-        funcData.push(data);
-        data = {
-          name: '',
-          inputs: [],
-          outputs: []
-        };
-        isHeader = false;
-      }
+    return hasContent ? data : null;
+  }
+  let i = 0;
+  const scriptHeaderLines = [];
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (line.startsWith('//')) scriptHeaderLines.push(line);else if (line === '') break;else break;
+    i++;
+  }
+  const scriptData = parseHeaderLines(scriptHeaderLines);
+  if (scriptData) funcData.push(scriptData);
+  for (; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.match(funcStartRegex)) continue;
+    const headerLines = [];
+    for (let j = i - 1; j >= 0; j--) {
+      const prevLine = lines[j].trim();
+      if (!prevLine.startsWith('//')) break;
+      headerLines.unshift(prevLine);
     }
+    const funcMeta = parseHeaderLines(headerLines);
+    if (funcMeta) funcData.push(funcMeta);
   }
   return {
     meta: funcData,