@hybridlabor-api/aos 4.3.0 → 4.4.1

package/mcps/unreal_mcp/tests/parameter-audit-coverage.mjs

@@ -1,164 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { repoRoot, reportsDir } from './parameter-audit-context.mjs';
-import { extractToolSchemas } from './parameter-audit-schema.mjs';
-import {
-  argumentSignature,
-  captureTestSuites,
-  groupCasesByTool,
-  liveReportCases
-} from './parameter-audit-suites.mjs';
-
-function staticCasesFromSuites(suites) {
-  const staticCases = [];
-  for (const suite of suites) {
-    for (const testCase of suite.cases) {
-      const args = testCase.arguments ?? {};
-      if (!testCase.toolName || typeof args.action !== 'string') continue;
-      staticCases.push({
-        suite: suite.name,
-        filePath: suite.filePath,
-        scenario: testCase.scenario,
-        toolName: testCase.toolName,
-        action: args.action,
-        expected: testCase.expected,
-        parameters: Object.keys(args).filter((key) => key !== 'action').sort(),
-        signature: argumentSignature(args)
-      });
-    }
-  }
-  return staticCases;
-}
-
-function summarizeToolCoverage(schema, casesByTool, parameterCoverageCasesByTool) {
-  const toolCases = casesByTool.get(schema.name) ?? [];
-  const toolParameterCoverageCases = parameterCoverageCasesByTool.get(schema.name) ?? [];
-  const testedActions = new Set(toolCases.map((testCase) => testCase.action));
-  const usedParameters = new Set(toolCases.flatMap((testCase) => testCase.parameters));
-  const successfulParameters = new Set(toolParameterCoverageCases.flatMap((testCase) => testCase.parameters));
-  const required = new Set(schema.required);
-  const optionalParameters = schema.properties.filter((property) => !required.has(property) && property !== 'action');
-  const declaredProperties = new Set(schema.properties);
-  const declaredActions = new Set(schema.actions);
-  const missingOptionalParameters = optionalParameters.filter((parameter) => !successfulParameters.has(parameter)).sort();
-
-  return {
-    tool: schema.name,
-    declaredActions: schema.actions.length,
-    testedActions: testedActions.size,
-    missingActions: schema.actions.filter((action) => !testedActions.has(action)),
-    extraActions: [...testedActions].filter((action) => !declaredActions.has(action)).sort(),
-    optionalParameters: optionalParameters.length,
-    coveredOptionalParameters: optionalParameters.filter((parameter) => successfulParameters.has(parameter)).length,
-    missingOptionalParameters,
-    failureOnlyOptionalParameters: missingOptionalParameters.filter((parameter) => usedParameters.has(parameter)),
-    extraParameters: [...usedParameters].filter((parameter) => !declaredProperties.has(parameter)).sort(),
-    actions: schema.actions.map((action) => {
-      const actionCases = toolCases.filter((testCase) => testCase.action === action);
-      return {
-        action,
-        caseCount: actionCases.length,
-        parameterCombinations: [...new Set(actionCases.map((testCase) => testCase.signature))].sort()
-      };
-    })
-  };
-}
-
-function summarizeTotals(tools, suites, staticCases, cases, parameterCoverageCases, live) {
-  return tools.reduce(
-    (acc, tool) => {
-      acc.declaredActions += tool.declaredActions;
-      acc.testedActions += tool.testedActions;
-      acc.missingActions += tool.missingActions.length;
-      acc.extraActions += tool.extraActions.length;
-      acc.optionalParameters += tool.optionalParameters;
-      acc.coveredOptionalParameters += tool.coveredOptionalParameters;
-      acc.missingOptionalParameters += tool.missingOptionalParameters.length;
-      acc.failureOnlyOptionalParameters += tool.failureOnlyOptionalParameters.length;
-      acc.extraParameters += tool.extraParameters.length;
-      return acc;
-    },
-    {
-      declaredActions: 0,
-      testedActions: 0,
-      missingActions: 0,
-      extraActions: 0,
-      optionalParameters: 0,
-      coveredOptionalParameters: 0,
-      missingOptionalParameters: 0,
-      failureOnlyOptionalParameters: 0,
-      extraParameters: 0,
-      testSuites: suites.length,
-      staticTestCases: staticCases.length,
-      coveredTestCases: cases.length,
-      parameterCoverageTestCases: parameterCoverageCases.length,
-      missingLiveReports: live.missingReports.length,
-      failedLiveCases: live.failedCases.length,
-      handledFailureLiveCases: live.handledFailureCases.length
-    }
-  );
-}
-
-export async function buildAudit(options) {
-  const schemas = extractToolSchemas();
-  const suites = await captureTestSuites();
-  const staticCases = staticCasesFromSuites(suites);
-  const live = options.staticOnly
-    ? { cases: [], missingReports: [], failedCases: [], handledFailureCases: [], reports: [] }
-    : liveReportCases(suites);
-  const cases = options.staticOnly ? staticCases : live.cases;
-  const parameterCoverageCases = options.staticOnly
-    ? cases
-    : cases.filter((testCase) => testCase.responseSuccess === true);
-  const casesByTool = groupCasesByTool(cases);
-  const parameterCoverageCasesByTool = groupCasesByTool(parameterCoverageCases);
-  const tools = schemas.map((schema) => summarizeToolCoverage(schema, casesByTool, parameterCoverageCasesByTool));
-
-  return {
-    generatedAt: new Date().toISOString(),
-    strict: options.strict,
-    optionalStrict: options.optionalStrict,
-    coverageBasis: options.staticOnly ? 'static-test-definitions' : 'successful-live-report-cases',
-    missingLiveReports: live.missingReports,
-    failedLiveCases: live.failedCases,
-    handledFailureLiveCases: live.handledFailureCases,
-    liveReports: live.reports,
-    totals: summarizeTotals(tools, suites, staticCases, cases, parameterCoverageCases, live),
-    tools
-  };
-}
-
-export function writeReport(audit) {
-  fs.mkdirSync(reportsDir, { recursive: true });
-  const reportPath = path.join(reportsDir, `parameter-combination-audit-${audit.generatedAt.replace(/[:]/g, '-')}.json`);
-  fs.writeFileSync(reportPath, JSON.stringify(audit, null, 2));
-  return reportPath;
-}
-
-export function printSummary(audit, reportPath) {
-  console.log('Parameter Combination Audit');
-  console.log(`Coverage basis: ${audit.coverageBasis}`);
-  console.log(`Suites: ${audit.totals.testSuites}`);
-  console.log(`Static test cases: ${audit.totals.staticTestCases}`);
-  console.log(`Covered test cases: ${audit.totals.coveredTestCases}`);
-  console.log(`Parameter coverage test cases: ${audit.totals.parameterCoverageTestCases}`);
-  console.log(`Missing live reports: ${audit.totals.missingLiveReports}`);
-  console.log(`Failed live cases: ${audit.totals.failedLiveCases}`);
-  console.log(`Handled live failure cases: ${audit.totals.handledFailureLiveCases}`);
-  console.log(`Actions: ${audit.totals.testedActions}/${audit.totals.declaredActions} covered`);
-  console.log(`Optional parameters: ${audit.totals.coveredOptionalParameters}/${audit.totals.optionalParameters} referenced by parameter coverage tests`);
-  console.log(`Unreferenced optional parameters: ${audit.totals.missingOptionalParameters}`);
-  console.log(`Failure-only optional parameters: ${audit.totals.failureOnlyOptionalParameters}`);
-  console.log(`Extra test parameters not declared in schema: ${audit.totals.extraParameters}`);
-  console.log(`Report: ${path.relative(repoRoot, reportPath)}`);
-
-  const toolsWithGaps = audit.tools.filter(
-    (tool) => tool.missingActions.length > 0 || tool.missingOptionalParameters.length > 0 || tool.extraParameters.length > 0
-  );
-  if (toolsWithGaps.length > 0) {
-    console.log('Tools with gaps:');
-    for (const tool of toolsWithGaps) {
-      console.log(`- ${tool.tool}: missingActions=${tool.missingActions.length}, missingOptionalParameters=${tool.missingOptionalParameters.length}, failureOnlyOptionalParameters=${tool.failureOnlyOptionalParameters.length}, extraParameters=${tool.extraParameters.length}`);
-    }
-  }
-}

package/mcps/unreal_mcp/tests/parameter-audit-schema.mjs

@@ -1,190 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import ts from 'typescript';
-import { definitionsRoot as defaultDefinitionsRoot } from './parameter-audit-context.mjs';
-
-function propertyName(node) {
-  if (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name) || ts.isNumericLiteral(node.name)) {
-    return node.name.text;
-  }
-  return undefined;
-}
-
-function getProperty(objectLiteral, name) {
-  for (const property of objectLiteral.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    if (propertyName(property) === name) return property.initializer;
-  }
-  return undefined;
-}
-
-function sourcePathsFromDefinitions(definitionsRoot) {
-  const sourcePaths = [];
-  const pendingDirectories = [definitionsRoot];
-
-  while (pendingDirectories.length > 0) {
-    const currentDirectory = pendingDirectories.pop();
-    for (const entry of fs.readdirSync(currentDirectory, { withFileTypes: true })) {
-      const entryPath = path.join(currentDirectory, entry.name);
-      if (entry.isDirectory()) {
-        pendingDirectories.push(entryPath);
-      } else if (entry.name.endsWith('.ts')) {
-        sourcePaths.push(entryPath);
-      }
-    }
-  }
-
-  return sourcePaths.sort();
-}
-
-function unwrapExpression(node) {
-  let current = node;
-  while (
-    ts.isAsExpression(current)
-    || ts.isParenthesizedExpression(current)
-    || ts.isSatisfiesExpression(current)
-    || ts.isTypeAssertionExpression(current)
-  ) {
-    current = current.expression;
-  }
-  return current;
-}
-
-function declarationInitializer(symbol) {
-  const declaration = symbol.valueDeclaration
-    ?? symbol.declarations?.find((candidate) => ts.isVariableDeclaration(candidate));
-  return declaration && ts.isVariableDeclaration(declaration)
-    ? declaration.initializer
-    : undefined;
-}
-
-function resolveExpression(node, checker, resolving = new Set()) {
-  const expression = unwrapExpression(node);
-  if (!ts.isIdentifier(expression)) return expression;
-
-  const locatedSymbol = checker.getSymbolAtLocation(expression);
-  if (!locatedSymbol) return undefined;
-  const symbol = locatedSymbol.flags & ts.SymbolFlags.Alias
-    ? checker.getAliasedSymbol(locatedSymbol)
-    : locatedSymbol;
-  if (resolving.has(symbol)) return undefined;
-
-  const initializer = declarationInitializer(symbol);
-  if (!initializer) return undefined;
-  const nextResolving = new Set(resolving);
-  nextResolving.add(symbol);
-  return resolveExpression(initializer, checker, nextResolving);
-}
-
-function stringArray(node, checker) {
-  const resolved = resolveExpression(node, checker);
-  if (!resolved || !ts.isArrayLiteralExpression(resolved)) return [];
-
-  const values = [];
-  for (const element of resolved.elements) {
-    if (ts.isStringLiteral(element) || ts.isNoSubstitutionTemplateLiteral(element)) {
-      values.push(element.text);
-    } else if (ts.isSpreadElement(element)) {
-      values.push(...stringArray(element.expression, checker));
-    }
-  }
-  return [...new Set(values)].sort();
-}
-
-function collectProperties(propertiesNode, checker, resolving = new Set()) {
-  const resolved = resolveExpression(propertiesNode, checker, resolving);
-  if (!resolved || !ts.isObjectLiteralExpression(resolved)) return { names: [], actionEnum: [] };
-  const names = [];
-  let actionEnum = [];
-
-  for (const property of resolved.properties) {
-    if (ts.isSpreadAssignment(property)) {
-      const spread = collectProperties(property.expression, checker, resolving);
-      names.push(...spread.names);
-      if (spread.names.includes('action')) actionEnum = spread.actionEnum;
-      continue;
-    }
-    if (!ts.isPropertyAssignment(property)) continue;
-    const name = propertyName(property);
-    if (typeof name !== 'string') continue;
-    names.push(name);
-    if (name === 'action') {
-      actionEnum = [];
-      const action = resolveExpression(property.initializer, checker);
-      if (action && ts.isObjectLiteralExpression(action)) {
-        const enumNode = getProperty(action, 'enum');
-        if (enumNode) actionEnum = stringArray(enumNode, checker);
-      }
-    }
-  }
-
-  return { names: [...new Set(names)].sort(), actionEnum };
-}
-
-function createDefinitionsProgram(definitionsRoot) {
-  const sourcePaths = sourcePathsFromDefinitions(definitionsRoot);
-  const program = ts.createProgram({
-    rootNames: sourcePaths,
-    options: {
-      target: ts.ScriptTarget.ES2022,
-      module: ts.ModuleKind.NodeNext,
-      moduleResolution: ts.ModuleResolutionKind.NodeNext,
-      skipLibCheck: true
-    }
-  });
-  const sourceFiles = sourcePaths
-    .map((filePath) => program.getSourceFile(filePath))
-    .filter((sourceFile) => sourceFile !== undefined);
-  return { program, sourceFiles };
-}
-
-function toolDefinitionDeclarations(sourceFiles) {
-  const declarations = [];
-  for (const sourceFile of sourceFiles) {
-    for (const statement of sourceFile.statements) {
-      if (!ts.isVariableStatement(statement)) continue;
-      for (const declaration of statement.declarationList.declarations) {
-        if (
-          ts.isIdentifier(declaration.name)
-          && declaration.name.text.endsWith('ToolDefinition')
-          && declaration.initializer
-        ) {
-          declarations.push(declaration);
-        }
-      }
-    }
-  }
-  return declarations;
-}
-
-export function extractToolSchemas(config = {}) {
-  const definitionsRoot = config.definitionsRoot ?? defaultDefinitionsRoot;
-  const { program, sourceFiles } = createDefinitionsProgram(definitionsRoot);
-  const checker = program.getTypeChecker();
-  const tools = [];
-
-  for (const declaration of toolDefinitionDeclarations(sourceFiles)) {
-    const initializer = resolveExpression(declaration.initializer, checker);
-    if (!initializer || !ts.isObjectLiteralExpression(initializer)) continue;
-    const nameNode = getProperty(initializer, 'name');
-    if (!nameNode || !ts.isStringLiteral(nameNode)) continue;
-    const inputSchemaNode = getProperty(initializer, 'inputSchema');
-    const inputSchema = inputSchemaNode
-      ? resolveExpression(inputSchemaNode, checker)
-      : undefined;
-    if (!inputSchema || !ts.isObjectLiteralExpression(inputSchema)) continue;
-    const properties = getProperty(inputSchema, 'properties');
-    if (!properties) continue;
-    const required = getProperty(inputSchema, 'required');
-    const collected = collectProperties(properties, checker);
-
-    tools.push({
-      name: nameNode.text,
-      actions: collected.actionEnum,
-      properties: collected.names,
-      required: required ? stringArray(required, checker) : []
-    });
-  }
-
-  return tools.sort((left, right) => left.name.localeCompare(right.name));
-}

package/mcps/unreal_mcp/tests/parameter-audit-suites.mjs

@@ -1,218 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { expectedCondition } from './expectation-utils.mjs';
-import {
-  AsyncFunction,
-  integrationSuitePath,
-  repoRoot,
-  reportsDir,
-  requireFromAudit,
-  testsRoot
-} from './parameter-audit-context.mjs';
-
-const fakeSuccessIndicators = ['not implemented', 'unsupported', 'stub', 'no-op', 'noop', 'placeholder'];
-
-export function argumentSignature(args) {
-  return Object.keys(args ?? {})
-    .filter((key) => key !== 'action')
-    .sort()
-    .join('+');
-}
-
-function caseKey(suiteName, toolName, args, scenario) {
-  return [suiteName, toolName ?? '', args?.action ?? '', argumentSignature(args), scenario ?? ''].join('\u001f');
-}
-
-export function groupCasesByTool(cases) {
-  const groups = new Map();
-  for (const testCase of cases) {
-    const toolCases = groups.get(testCase.toolName);
-    if (toolCases) {
-      toolCases.push(testCase);
-    } else {
-      groups.set(testCase.toolName, [testCase]);
-    }
-  }
-  return groups;
-}
-
-function walkMjsFiles(dir) {
-  const files = [];
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) files.push(...walkMjsFiles(fullPath));
-    if (entry.isFile() && entry.name.endsWith('.mjs')) files.push(fullPath);
-  }
-  return files;
-}
-
-function testSuiteFiles() {
-  const files = walkMjsFiles(testsRoot);
-  if (fs.existsSync(integrationSuitePath)) files.push(integrationSuitePath);
-  return files.sort();
-}
-
-function auditRequire(specifier) {
-  if (specifier === 'node:fs') {
-    return {
-      mkdirSync() {},
-      writeFileSync() {},
-      existsSync: fs.existsSync,
-      readFileSync: fs.readFileSync,
-      readdirSync: fs.readdirSync,
-      statSync: fs.statSync
-    };
-  }
-  return requireFromAudit(specifier);
-}
-
-export async function captureTestSuites() {
-  const suites = [];
-  for (const filePath of testSuiteFiles()) {
-    let code = fs.readFileSync(filePath, 'utf8').replace(/^#!.*\n/, '');
-    code = code.replace(
-      /import \{ runToolTests \} from ['"](?:\.\.\/\.\.\/test-runner|\.\/test-runner)\.mjs['"];?/g,
-      'const runToolTests = (name, cases) => { __captured.push({ name, cases }); };'
-    );
-    code = code.replace(/import fs from ['"]node:fs['"];?/g, "const fs = require('node:fs');");
-    code = code.replace(/import path from ['"]node:path['"];?/g, "const path = require('node:path');");
-
-    const captured = [];
-    await AsyncFunction('require', '__captured', 'process', 'console', 'Date', code)(
-      auditRequire,
-      captured,
-      process,
-      { log() {}, warn() {}, error() {} },
-      Date
-    );
-
-    for (const suite of captured) {
-      suites.push({ filePath: path.relative(repoRoot, filePath), name: suite.name, cases: suite.cases ?? [] });
-    }
-  }
-  return suites;
-}
-
-function latestReportsForSuites(suiteNames) {
-  const latestReports = new Map();
-  if (!fs.existsSync(reportsDir)) return latestReports;
-
-  const suitePrefixes = suiteNames.map((suiteName) => ({ suiteName, prefix: `${suiteName}-test-results-` }));
-  for (const entry of fs.readdirSync(reportsDir)) {
-    if (!entry.endsWith('.json')) continue;
-    const suite = suitePrefixes.find(({ prefix }) => entry.startsWith(prefix));
-    if (!suite) continue;
-
-    const candidate = path.join(reportsDir, entry);
-    try {
-      const report = JSON.parse(fs.readFileSync(candidate, 'utf8'));
-      const latest = latestReports.get(suite.suiteName);
-      if (!latest || String(report.generatedAt ?? '') > String(latest.report.generatedAt ?? '')) {
-        latestReports.set(suite.suiteName, { path: candidate, report });
-      }
-    } catch {
-      // Malformed historical reports cannot prove coverage.
-    }
-  }
-
-  return latestReports;
-}
-
-function staticCasesByKey(suites) {
-  const casesByKey = new Map();
-  for (const suite of suites) {
-    for (const testCase of suite.cases ?? []) {
-      const args = testCase.arguments ?? {};
-      if (!testCase.toolName || typeof args.action !== 'string') continue;
-      casesByKey.set(caseKey(suite.name, testCase.toolName, args, testCase.scenario), testCase);
-    }
-  }
-  return casesByKey;
-}
-
-function recordLiveCase(result, suiteName, staticCase, failedCases, handledFailureCases, cases, reportPath) {
-  const args = result.arguments ?? {};
-  const expected = result.expected ?? staticCase?.expected;
-  const hasOutcomeFields = typeof result.responseSuccess === 'boolean' || typeof result.responseIsError === 'boolean';
-  if (!hasOutcomeFields) {
-    failedCases.push({ suite: suiteName, scenario: result.scenario, status: 'passed-without-response-outcome', expected: expectedCondition(expected) });
-    return;
-  }
-
-  const responseSucceeded = result.responseSuccess === true && result.responseIsError !== true;
-  const responseFailedAsExpected = result.responseSuccess === false || result.responseIsError === true;
-  if (!responseSucceeded && !responseFailedAsExpected) {
-    failedCases.push({
-      suite: suiteName,
-      scenario: result.scenario,
-      status: 'passed-with-unsuccessful-response',
-      responseSuccess: result.responseSuccess,
-      responseIsError: result.responseIsError,
-      responseError: result.responseError
-    });
-    return;
-  }
-
-  if (responseSucceeded) {
-    const successText = [result.detail, result.responseMessage, result.responseError]
-      .filter((value) => typeof value === 'string')
-      .join('\n')
-      .toLowerCase();
-    if (fakeSuccessIndicators.some((indicator) => successText.includes(indicator))) {
-      failedCases.push({ suite: suiteName, scenario: result.scenario, status: 'passed-with-fake-success-indicator' });
-      return;
-    }
-  } else {
-    handledFailureCases.push({
-      suite: suiteName,
-      scenario: result.scenario,
-      expected: expectedCondition(expected),
-      responseError: result.responseError,
-      responseMessage: result.responseMessage
-    });
-  }
-
-  cases.push({
-    suite: suiteName,
-    filePath: path.relative(repoRoot, reportPath),
-    scenario: result.scenario,
-    toolName: result.toolName,
-    action: args.action,
-    parameters: Object.keys(args).filter((key) => key !== 'action').sort(),
-    signature: argumentSignature(args),
-    responseSuccess: result.responseSuccess
-  });
-}
-
-export function liveReportCases(suites) {
-  const suiteNames = [...new Set(suites.map((suite) => suite.name))].sort();
-  const latestReports = latestReportsForSuites(suiteNames);
-  const casesByKey = staticCasesByKey(suites);
-  const missingReports = [];
-  const failedCases = [];
-  const handledFailureCases = [];
-  const reports = [];
-  const cases = [];
-
-  for (const suiteName of suiteNames) {
-    const latest = latestReports.get(suiteName);
-    if (!latest) {
-      missingReports.push(suiteName);
-      continue;
-    }
-
-    reports.push(path.relative(repoRoot, latest.path));
-    for (const result of latest.report.results ?? []) {
-      if (result.status !== 'passed') {
-        failedCases.push({ suite: suiteName, scenario: result.scenario, status: result.status });
-        continue;
-      }
-      const args = result.arguments ?? {};
-      if (!result.toolName || typeof args.action !== 'string') continue;
-      const staticCase = casesByKey.get(caseKey(suiteName, result.toolName, args, result.scenario));
-      recordLiveCase(result, suiteName, staticCase, failedCases, handledFailureCases, cases, latest.path);
-    }
-  }
-
-  return { cases, missingReports, failedCases, handledFailureCases, reports };
-}

package/mcps/unreal_mcp/tests/parameter-combination-audit.mjs

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-
-import { parseAuditOptions, printUsage } from './parameter-audit-cli.mjs';
-import { buildAudit, printSummary, writeReport } from './parameter-audit-coverage.mjs';
-
-const options = parseAuditOptions(process.argv.slice(2));
-
-if (options.help) {
-  printUsage();
-  process.exit(0);
-}
-
-if (options.unknownFlags.length > 0) {
-  console.error(`Unknown option(s): ${options.unknownFlags.join(', ')}`);
-  console.error('Run with --help for usage.');
-  process.exit(2);
-}
-
-const audit = await buildAudit(options);
-const reportPath = writeReport(audit);
-printSummary(audit, reportPath);
-
-if (audit.totals.missingActions > 0 || audit.totals.extraActions > 0) {
-  process.exitCode = 1;
-}
-
-if (!options.staticOnly && (audit.totals.missingLiveReports > 0 || audit.totals.failedLiveCases > 0)) {
-  process.exitCode = 1;
-}
-
-if (options.strict && audit.totals.extraParameters > 0) {
-  process.exitCode = 1;
-}
-
-if (options.optionalStrict && audit.totals.missingOptionalParameters > 0) {
-  process.exitCode = 1;
-}