@ngockhoale/ukit 1.1.6

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@ngockhoale/ukit",
+  "version": "1.1.6",
+  "description": "Install/update an index-first AI workspace for Claude Code, Antigravity, OpenAI Codex, and OpenCode.",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "ukit",
+    "claude",
+    "codex",
+    "antigravity",
+    "claude-code",
+    "opencode",
+    "skills",
+    "agents",
+    "ai",
+    "ai-workspace",
+    "cli",
+    "developer-tools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lengockhoa/UKit.git"
+  },
+  "homepage": "https://github.com/lengockhoa/UKit#readme",
+  "bugs": {
+    "url": "https://github.com/lengockhoa/UKit/issues"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "scripts/",
+    "templates/",
+    "CHANGELOG.md",
+    "LICENSE",
+    "templates/CLAUDE.md",
+    "templates/AGENTS.md",
+    "templates/.gitignore",
+    "manifests/",
+    "templates/adapter-presets/opencode/opencode.template.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "ukit": "bin/ukit"
+  },
+  "scripts": {
+    "start": "node ./bin/ukit",
+    "doctor": "node ./bin/ukit doctor",
+    "diff": "node ./bin/ukit diff",
+    "index:build": "node ./scripts/index/build-index.mjs",
+    "index:refresh": "node ./scripts/index/refresh-index.mjs",
+    "index:query": "node ./scripts/index/query-index.mjs",
+    "bug:triage": "node ./scripts/bug/triage.mjs",
+    "test:artifact": "vitest run tests/integration/packageArtifact.test.js",
+    "test:release-core": "vitest run --exclude tests/integration/packageArtifact.test.js",
+    "release:verify": "node ./scripts/release/verify-release.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "vitest": "^2"
+  }
+}

package/scripts/bug/triage.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import path from 'node:path';
+
+import { triageBug } from '../../src/bug/triageBug.js';
+
+const args = process.argv.slice(2);
+const rootArg = readFlagValue(args, '--root');
+const rootDir = rootArg ? path.resolve(rootArg) : process.cwd();
+
+const signature = args.filter((arg) => !arg.startsWith('--')).join(' ').trim();
+
+if (!signature) {
+  console.error('Usage: yarn bug:triage -- "<error signature>"');
+  process.exitCode = 1;
+} else {
+  const result = await triageBug({ rootDir, signature });
+  console.log('[bug:triage]');
+  console.log(`lane: ${result.lane}`);
+  console.log(`confidence: ${result.confidence.toFixed(2)}`);
+  console.log(`signature: ${result.signature}`);
+  console.log(`suspects: ${result.suspectFiles.join(', ') || 'none'}`);
+  console.log(`test: ${result.recommendedTestCommand}`);
+}
+
+function readFlagValue(argv, flag) {
+  const exact = argv.indexOf(flag);
+  if (exact >= 0 && argv[exact + 1]) {
+    return argv[exact + 1];
+  }
+
+  const withEquals = argv.find((item) => item.startsWith(`${flag}=`));
+  if (withEquals) {
+    return withEquals.slice(flag.length + 1);
+  }
+
+  return null;
+}

package/scripts/index/build-index.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import path from 'node:path';
+
+import { buildCodeIndex } from '../../src/index/buildIndex.js';
+
+const args = process.argv.slice(2);
+const rootArg = readFlagValue(args, '--root');
+const rootDir = rootArg ? path.resolve(rootArg) : process.cwd();
+
+const summary = await buildCodeIndex({ rootDir });
+
+console.log('[index:build] completed');
+console.log(`root: ${rootDir}`);
+console.log(`files: ${summary.fileCount}`);
+console.log(`symbols: ${summary.symbolCount}`);
+console.log(`imports: ${summary.importCount}`);
+console.log(`tests-map: ${summary.testsMapCount}`);
+console.log(`hotspots: ${summary.hotspotCount}`);
+console.log(`parsed: ${summary.parsedCodeFileCount}`);
+console.log(`reused: ${summary.reusedCodeFileCount}`);
+console.log(`indexDir: ${summary.indexDir}`);
+
+function readFlagValue(argv, flag) {
+  const exact = argv.indexOf(flag);
+  if (exact >= 0 && argv[exact + 1]) {
+    return argv[exact + 1];
+  }
+
+  const withEquals = argv.find((item) => item.startsWith(`${flag}=`));
+  if (withEquals) {
+    return withEquals.slice(flag.length + 1);
+  }
+
+  return null;
+}

package/scripts/index/query-index.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import path from 'node:path';
+
+import {
+  queryCodeIndex,
+} from '../../src/index/queryIndex.js';
+import {
+  buildCodeIndex,
+  isIndexStale,
+  DEFAULT_INDEX_CACHE_MAX_AGE_MS,
+} from '../../src/index/buildIndex.js';
+import { parseIndexArgs, QUERY_FLAG_DEFINITIONS } from '../../src/cli/commands/indexArgs.js';
+
+const args = process.argv.slice(2);
+const { value: rootArg, args: afterRootArgs } = extractFlagValue(args, '--root');
+const { value: changedArg, args: remainingArgs } = extractFlagValue(afterRootArgs, '--changed');
+const changedFiles = changedArg
+  ? changedArg.split(',').map((item) => item.trim()).filter(Boolean)
+  : [];
+const rootDir = rootArg ? path.resolve(rootArg) : process.cwd();
+
+const { tokens, flags } = parseIndexArgs(remainingArgs, QUERY_FLAG_DEFINITIONS);
+const query = tokens.join(' ').trim();
+if (!query) {
+  console.error('Usage: yarn index:query -- "<error|symbol|path>" [--limit N] [--changed fileA,fileB]');
+  process.exitCode = 1;
+} else {
+  const stale = await isIndexStale({ rootDir, maxAgeMs: DEFAULT_INDEX_CACHE_MAX_AGE_MS });
+  if (stale) {
+    await buildCodeIndex({ rootDir });
+  }
+
+  const limit = Number.parseInt(flags.get('--limit') ?? '5', 10);
+  const results = await queryCodeIndex({
+    rootDir,
+    query,
+    limit: Number.isNaN(limit) ? 5 : limit,
+  });
+
+  if (changedFiles.length > 0) {
+    console.log(`changed-files-hint: ${changedFiles.join(', ')}`);
+  }
+
+  if (results.length === 0) {
+    console.log('[index:query] no matches');
+  } else {
+    console.log(`[index:query] top ${results.length} matches for: ${query}`);
+    for (const [idx, item] of results.entries()) {
+      console.log(`${idx + 1}. ${item.filePath} (score=${item.score})`);
+      if ((item.tests ?? []).length > 0) {
+        console.log(`   tests: ${item.tests.slice(0, 2).join(', ')}`);
+      }
+      if ((item.reasons ?? []).length > 0) {
+        console.log(`   reasons: ${item.reasons.join(', ')}`);
+      }
+    }
+  }
+}
+
+function extractFlagValue(argv, flag) {
+  let value = null;
+  const nextArgs = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (arg === flag) {
+      if (value !== null) {
+        nextArgs.push(arg);
+        continue;
+      }
+      const maybeValue = argv[i + 1];
+      if (!maybeValue || maybeValue.startsWith('--')) {
+        throw new Error(`Missing value for ${flag}.`);
+      }
+      value = maybeValue;
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith(`${flag}=`)) {
+      if (value === null) {
+        value = arg.slice(flag.length + 1);
+        continue;
+      }
+    }
+
+    nextArgs.push(arg);
+  }
+
+  return { value, args: nextArgs };
+}

package/scripts/index/refresh-index.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  buildCodeIndex,
+  isIndexStale,
+  DEFAULT_INDEX_CACHE_MAX_AGE_MS,
+} from '../../src/index/buildIndex.js';
+
+const args = process.argv.slice(2);
+const rootArg = readFlagValue(args, '--root');
+const rootDir = rootArg ? path.resolve(rootArg) : process.cwd();
+
+const changedArg = readFlagValue(args, '--changed');
+const changedFiles = changedArg
+  ? changedArg.split(',').map((item) => item.trim()).filter(Boolean)
+  : [];
+
+const force = readBooleanFlag(args, '--force');
+const lastRefreshMs = await getLastRefreshTime(rootDir);
+const stale = force
+  ? true
+  : await isIndexStale({ rootDir, maxAgeMs: DEFAULT_INDEX_CACHE_MAX_AGE_MS });
+
+if (!stale) {
+  console.log('[index:refresh] skipped (cache fresh)');
+  if (lastRefreshMs !== null) {
+    console.log(`lastRefresh: ${new Date(lastRefreshMs).toISOString()}`);
+  }
+  if (changedFiles.length > 0) {
+    console.log(`changed-files-hint: ${changedFiles.join(', ')}`);
+  }
+  console.log(`root: ${rootDir}`);
+} else {
+  const summary = await buildCodeIndex({ rootDir });
+
+  console.log('[index:refresh] completed');
+  if (lastRefreshMs !== null) {
+    console.log(`lastRefreshBefore: ${new Date(lastRefreshMs).toISOString()}`);
+  }
+  if (changedFiles.length > 0) {
+    console.log(`changed-files-hint: ${changedFiles.join(', ')}`);
+  }
+  console.log(`root: ${rootDir}`);
+  console.log(`files: ${summary.fileCount}`);
+  console.log(`parsed: ${summary.parsedCodeFileCount}`);
+  console.log(`reused: ${summary.reusedCodeFileCount}`);
+  console.log(`indexDir: ${summary.indexDir}`);
+}
+
+function readFlagValue(argv, flag) {
+  const exact = argv.indexOf(flag);
+  if (exact >= 0 && argv[exact + 1]) {
+    return argv[exact + 1];
+  }
+
+  const withEquals = argv.find((item) => item.startsWith(`${flag}=`));
+  if (withEquals) {
+    return withEquals.slice(flag.length + 1);
+  }
+
+  return null;
+}
+
+function readBooleanFlag(argv, flag) {
+  return argv.includes(flag);
+}
+
+async function getLastRefreshTime(rootDir) {
+  const filesPath = path.join(rootDir, '.cache', 'index', 'files.json');
+
+  try {
+    const raw = await fs.readFile(filesPath, 'utf8');
+    const artifact = JSON.parse(raw);
+    const generatedAtRaw = String(artifact?.generatedAt ?? '').trim();
+    if (!generatedAtRaw) {
+      return null;
+    }
+    const generatedAtMs = Date.parse(generatedAtRaw);
+    return Number.isNaN(generatedAtMs) ? null : generatedAtMs;
+  } catch {
+    return null;
+  }
+}

package/scripts/release/verify-release.mjs

@@ -0,0 +1,56 @@
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+
+const rootDir = process.cwd();
+const npmCacheDir = path.join(os.tmpdir(), 'ukit-npm-cache');
+
+const steps = [
+  {
+    label: 'Artifact smoke',
+    command: 'yarn',
+    args: ['test:artifact'],
+    env: process.env,
+  },
+  {
+    label: 'Core test suite',
+    command: 'yarn',
+    args: ['test:release-core'],
+    env: process.env,
+  },
+  {
+    label: 'Local package dry-run',
+    command: 'npm',
+    args: ['pack', '--dry-run', '--json', '--cache', npmCacheDir],
+    env: {
+      ...process.env,
+      npm_config_cache: npmCacheDir,
+    },
+  },
+];
+
+for (const step of steps) {
+  console.log(`\n[release:verify] ${step.label}`);
+  console.log(`[release:verify] > ${step.command} ${step.args.join(' ')}`);
+
+  const exitCode = await runStep(step);
+  if (exitCode !== 0) {
+    console.error(`[release:verify] FAILED at step: ${step.label}`);
+    process.exit(exitCode ?? 1);
+  }
+}
+
+console.log('\n[release:verify] All release checks passed.');
+
+function runStep({ command, args, env }) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd: rootDir,
+      env,
+      stdio: 'inherit',
+    });
+
+    child.on('close', (code) => resolve(code ?? 1));
+    child.on('error', () => resolve(1));
+  });
+}

package/src/bug/triageBug.js

@@ -0,0 +1,123 @@
+import { queryCodeIndex } from '../index/queryIndex.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { inferRelatedTestsFromArtifacts, loadRelatedTestArtifacts } from '../index/relatedTests.js';
+
+const DEEP_KEYWORDS = ['race', 'flaky', 'intermittent', 'timeout', 'deadlock'];
+
+export async function triageBug({ rootDir = process.cwd(), signature } = {}) {
+  if (!signature || !signature.trim()) {
+    throw new Error('Bug signature is required. Usage: yarn bug:triage -- "<error signature>"');
+  }
+
+  const queryResults = await queryCodeIndex({ rootDir, query: signature, limit: 3 });
+  const prioritizedResults = [...queryResults].sort((a, b) => {
+    const aIsSource = a.filePath.startsWith('src/') ? 1 : 0;
+    const bIsSource = b.filePath.startsWith('src/') ? 1 : 0;
+    if (aIsSource !== bIsSource) {
+      return bIsSource - aIsSource;
+    }
+    return b.score - a.score;
+  });
+
+  const topResult = prioritizedResults[0] ?? null;
+
+  const deepByKeyword = DEEP_KEYWORDS.some((keyword) => signature.toLowerCase().includes(keyword));
+  const fastByScore = Boolean(topResult && topResult.score >= 8);
+  const directRecommendedTestFile = prioritizedResults
+    .flatMap((item) => item.tests ?? [])
+    .find(Boolean);
+  const shouldLoadRelatedArtifacts = Boolean(topResult) || !directRecommendedTestFile;
+  const relatedArtifacts = shouldLoadRelatedArtifacts
+    ? await loadRelatedTestArtifacts({ rootDir })
+    : null;
+  const inferredRecommendedTests = directRecommendedTestFile
+    ? []
+    : inferRelatedTestsFromArtifacts({
+      candidateFiles: prioritizedResults.map((item) => item.filePath),
+      analogsMap: relatedArtifacts?.analogsMap,
+      relationsMap: relatedArtifacts?.relationsMap,
+      limit: 3,
+    });
+  const recommendedTestFile = directRecommendedTestFile
+    ?? inferredRecommendedTests[0]?.filePath
+    ?? '<target-test-file>';
+
+  const lane = deepByKeyword ? 'deep' : (fastByScore ? 'fast' : 'deep');
+  const confidence = topResult ? Math.min(topResult.score / 20, 1) : 0;
+
+  const recommendedTest = await buildTestCommand(rootDir, recommendedTestFile);
+
+  const analogFiles = topResult
+    ? (relatedArtifacts?.analogsMap.get(topResult.filePath) ?? []).slice(0, 2)
+    : [];
+
+  return {
+    signature,
+    lane,
+    confidence,
+    suspectFiles: prioritizedResults.map((item) => item.filePath),
+    analogFiles: analogFiles.map((a) => a.filePath),
+    reasons: topResult?.reasons ?? [],
+    recommendedTestCommand: recommendedTest,
+    suggestedLoop: [
+      'Reproduce exactly once with the failing command',
+      'Open only top 1-3 suspect files from index output',
+      'If analogs found, open 1 analog file for pattern reference',
+      'Run one 15-minute loop: hypothesis -> patch -> targeted test',
+      'If two loops fail, switch to deep debugging lane',
+    ],
+  };
+}
+
+async function buildTestCommand(rootDir, testFile) {
+  const packageManager = await detectPackageManager(rootDir);
+
+  if (packageManager === 'pnpm') {
+    return `pnpm test ${testFile}`;
+  }
+
+  if (packageManager === 'yarn') {
+    return `yarn test ${testFile}`;
+  }
+
+  if (packageManager === 'bun') {
+    return `bun test ${testFile}`;
+  }
+
+  // npm default
+  return `npm test -- ${testFile}`;
+}
+
+async function detectPackageManager(rootDir) {
+  const packageJsonPath = path.join(rootDir, 'package.json');
+  try {
+    const raw = await fs.readFile(packageJsonPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    const declared = String(pkg?.packageManager ?? '').toLowerCase();
+    if (declared.startsWith('pnpm')) return 'pnpm';
+    if (declared.startsWith('yarn')) return 'yarn';
+    if (declared.startsWith('bun')) return 'bun';
+    if (declared.startsWith('npm')) return 'npm';
+  } catch {
+    // fall through to lockfile detection
+  }
+
+  const checks = [
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['bun.lockb', 'bun'],
+    ['package-lock.json', 'npm'],
+  ];
+
+  for (const [lockfile, pm] of checks) {
+    try {
+      await fs.access(path.join(rootDir, lockfile));
+      return pm;
+    } catch {
+      // continue
+    }
+  }
+
+  return 'npm';
+}

package/src/cli/adapters.js

@@ -0,0 +1,148 @@
+export const OPTIONAL_ADAPTERS = [
+  {
+    key: 'antigravity',
+    label: 'Antigravity',
+    itemIds: [
+      'multi-antigravity-skills-link',
+      'multi-antigravity-ukit-link',
+      'multi-antigravity-rules',
+      'multi-antigravity-readme',
+    ],
+    managedPaths: [
+      '.antigravity/skills',
+      '.antigravity/ukit',
+      '.antigravity/rules/rules.md',
+      '.antigravity/README.md',
+    ],
+  },
+  {
+    key: 'codex',
+    label: 'OpenAI Codex',
+    itemIds: [
+      'multi-codex-skills-link',
+      'multi-codex-ukit-link',
+      'multi-codex-readme',
+      'multi-codex-settings-json',
+      'multi-codex-settings-local',
+    ],
+    managedPaths: [
+      '.codex/skills',
+      '.codex/ukit',
+      '.codex/README.md',
+      '.codex/settings.json',
+      '.codex/settings.local.json',
+    ],
+  },
+  {
+    key: 'opencode',
+    label: 'OpenCode',
+    itemIds: [
+      'multi-opencode-config',
+    ],
+    managedPaths: [
+      'opencode.json',
+    ],
+  },
+];
+
+export const ADAPTER_BY_KEY = new Map(OPTIONAL_ADAPTERS.map((adapter) => [adapter.key, adapter]));
+export const DEFAULT_OPTIONAL_TOOL_KEYS = OPTIONAL_ADAPTERS.map((adapter) => adapter.key);
+
+export const TOOL_ALIASES = new Map([
+  ['claude', 'claude'],
+  ['claude-code', 'claude'],
+  ['antigravity', 'antigravity'],
+  ['codex', 'codex'],
+  ['openai-codex', 'codex'],
+  ['opencode', 'opencode'],
+  ['open-code', 'opencode'],
+]);
+
+export const TOOLS_FLAG_HELP = 'all|none|claude,antigravity,codex,opencode';
+
+export function parseToolsArg(argv = []) {
+  let toolsArg = null;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '--tools') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error(`Missing value for --tools. Use --tools=${TOOLS_FLAG_HELP}`);
+      }
+      toolsArg = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--tools=')) {
+      toolsArg = arg.slice('--tools='.length);
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${arg}. Supported: --tools=${TOOLS_FLAG_HELP}`);
+  }
+
+  return toolsArg;
+}
+
+export function resolveOptionalToolKeys(toolsArg) {
+  if (toolsArg === null) {
+    return [...DEFAULT_OPTIONAL_TOOL_KEYS];
+  }
+
+  const normalized = toolsArg.trim().toLowerCase();
+
+  if (normalized === 'all') {
+    return [...DEFAULT_OPTIONAL_TOOL_KEYS];
+  }
+
+  if (normalized === 'none') {
+    return [];
+  }
+
+  const selectedOptional = new Set();
+  for (const rawToken of toolsArg.split(',')) {
+    const token = rawToken.trim();
+    if (!token) continue;
+
+    const normalizedTool = TOOL_ALIASES.get(token.toLowerCase()) ?? null;
+    if (!normalizedTool) {
+      throw new Error(`Unknown tool '${token}'. Allowed: ${TOOLS_FLAG_HELP}`);
+    }
+
+    if (normalizedTool !== 'claude') {
+      selectedOptional.add(normalizedTool);
+    }
+  }
+
+  return OPTIONAL_ADAPTERS
+    .map((adapter) => adapter.key)
+    .filter((adapterKey) => selectedOptional.has(adapterKey));
+}
+
+export function toSelectedAdapterItemIds(optionalToolKeys) {
+  const itemIds = [];
+
+  for (const key of optionalToolKeys) {
+    const adapter = ADAPTER_BY_KEY.get(key);
+    if (!adapter) {
+      throw new Error(`Unsupported adapter key: ${key}`);
+    }
+    itemIds.push(...adapter.itemIds);
+  }
+
+  return itemIds;
+}
+
+export function formatSelectedTools(optionalToolKeys) {
+  const optionalLabels = optionalToolKeys
+    .map((key) => ADAPTER_BY_KEY.get(key))
+    .filter(Boolean)
+    .map((adapter) => adapter.label);
+
+  return optionalLabels.length > 0
+    ? `Claude Code, ${optionalLabels.join(', ')}`
+    : 'Claude Code';
+}

package/src/cli/commands/diff.js

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { buildPathConfig } from '../../core/paths.js';
+import { runInstallPipeline } from '../../core/runInstallPipeline.js';
+import { parseToolsArg, resolveOptionalToolKeys, toSelectedAdapterItemIds, formatSelectedTools } from '../adapters.js';
+
+export async function runDiff({ packageRoot, projectRoot, packageVersion, argv = [] }) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log('Usage: ukit diff [options]');
+    console.log('');
+    console.log('Preview install actions without writing any files.');
+    console.log('');
+    console.log('Options:');
+    console.log('  --tools=<list>  Adapters to include (default: all). Same as install.');
+    console.log('  --help, -h      Show this help message');
+    return;
+  }
+
+  const toolsArg = parseToolsArg(argv);
+  const selectedOptionalTools = resolveOptionalToolKeys(toolsArg);
+  const selectedAdapterItemIds = toSelectedAdapterItemIds(selectedOptionalTools);
+
+  const pathConfig = buildPathConfig({ packageRoot, projectRoot });
+
+  const result = await runInstallPipeline({
+    packageVersion,
+    pathConfig,
+    dryRun: true,
+    selectedAdapterItemIds,
+  });
+
+  console.log('[UKit] Diff preview:');
+  console.log(`[UKit] Manifest: ${result.manifest.name}`);
+  console.log(`[UKit] Tools selected: ${formatSelectedTools(selectedOptionalTools)}`);
+  console.log(`[UKit] Detected packs: ${result.stackContext.detectedPacks.join(', ')}`);
+
+  for (const row of result.rows) {
+    const relPath = path.relative(projectRoot, row.targetPath);
+    console.log(`- [${row.action}] ${row.id} -> ${relPath}`);
+  }
+
+  console.log(
+    `[UKit] Summary: create=${result.summary.create}, update=${result.summary.update}, unchanged=${result.summary.unchanged}, skip=${result.summary.skip}`,
+  );
+  const providerNames = Object.keys(result.providerContext.providers);
+  const providerStatus = providerNames
+    .map((name) => `${name}=${result.providerContext.providers[name].supported}`)
+    .join(', ');
+  console.log(
+    `[UKit] Providers: ${providerStatus}, all=${result.providerContext.allSupported}`,
+  );
+}