termsearch 0.3.1 → 0.3.2

package/src/search/engine.js

@@ -1,4 +1,4 @@
-// Search orchestrator — fan-out to all enabled providers, merge, rank, cache
+// Search orchestrator — fan-out to enabled providers, merge, rank, cache
 
 import path from 'path';
 import { makeTieredCache, searchCacheKey } from './cache.js';
@@ -8,74 +8,140 @@ import * as wikipedia from './providers/wikipedia.js';
 import * as brave from './providers/brave.js';
 import * as mojeek from './providers/mojeek.js';
 import * as searxng from './providers/searxng.js';
+import * as github from './providers/github.js';
 
 let _searchCache = null;
 let _docCache = null;
-let _dataDir = null;
 
-export function initCaches(dataDir, cfg) {
-  _dataDir = dataDir;
-  const sc = cfg.search;
-  _searchCache = makeTieredCache(
-    sc.cache_l1_max_search,
-    path.join(dataDir, 'cache', 'search'),
-    sc.disk_max_search_entries,
-    sc.disk_max_search_bytes,
-  );
-  _docCache = makeTieredCache(
-    sc.cache_l1_max_docs,
-    path.join(dataDir, 'cache', 'docs'),
-    sc.disk_max_doc_entries,
-    sc.disk_max_doc_bytes,
-  );
-}
+const ENGINE_HEALTH_HISTORY_LIMIT = 16;
+const ENGINE_HEALTH_STORE = new Map();
+const INFLIGHT_SEARCH_STORE = new Map();
 
-export function getDocCache() {
-  return _docCache;
-}
+export const ALLOWED_ENGINES = new Set([
+  'brave',
+  'duckduckgo',
+  'startpage',
+  'qwant',
+  'mojeek',
+  'google',
+  'bing',
+  'yahoo',
+  'gigablast',
+  'yacy',
+  'wikipedia',
+  'wikidata',
+  'reddit',
+  'github',
+  'youtube',
+  'hackernews',
+  'mastodon users',
+  'mastodon hashtags',
+  'tootfinder',
+  'lemmy communities',
+  'lemmy users',
+  'lemmy posts',
+  'lemmy comments',
+  'lobste.rs',
+  'sepiasearch',
+  'crossref',
+  'openalex',
+  'openlibrary',
+  '1337x',
+  'piratebay',
+  'nyaa',
+  // local aliases for direct providers
+  'ddg',
+  'wiki',
+  'searxng',
+  'searx',
+  'github-api',
+]);
+
+const CURATED_WEB_ENGINES = ['bing', 'startpage', 'yahoo', 'mojeek', 'github', 'reddit', 'youtube', 'hackernews'];
 
 const PROVIDER_REGISTRY = {
   duckduckgo: {
     aliases: new Set(['duckduckgo', 'ddg']),
     enabled: (_cfg) => true,
     run: ddg.search,
+    defaultProvider: true,
   },
   wikipedia: {
     aliases: new Set(['wikipedia', 'wiki']),
     enabled: (_cfg) => true,
     run: wikipedia.search,
+    defaultProvider: true,
   },
   brave: {
     aliases: new Set(['brave']),
     enabled: (cfg) => Boolean(cfg.brave?.enabled && cfg.brave?.api_key),
     run: brave.search,
+    defaultProvider: true,
   },
   mojeek: {
     aliases: new Set(['mojeek']),
     enabled: (cfg) => Boolean(cfg.mojeek?.enabled && cfg.mojeek?.api_key),
     run: mojeek.search,
+    defaultProvider: true,
   },
   searxng: {
     aliases: new Set(['searxng', 'searx']),
     enabled: (cfg) => Boolean(cfg.searxng?.enabled && cfg.searxng?.url),
     run: searxng.search,
+    defaultProvider: true,
+  },
+  github: {
+    aliases: new Set(['github', 'github-api']),
+    enabled: (_cfg) => true,
+    run: github.search,
+    defaultProvider: false,
   },
 };
 
+export function initCaches(dataDir, cfg) {
+  const sc = cfg.search;
+  _searchCache = makeTieredCache(
+    sc.cache_l1_max_search,
+    path.join(dataDir, 'cache', 'search'),
+    sc.disk_max_search_entries,
+    sc.disk_max_search_bytes,
+  );
+  _docCache = makeTieredCache(
+    sc.cache_l1_max_docs,
+    path.join(dataDir, 'cache', 'docs'),
+    sc.disk_max_doc_entries,
+    sc.disk_max_doc_bytes,
+  );
+}
+
+export function getDocCache() {
+  return _docCache;
+}
+
+function normalizeEngineName(engine) {
+  return String(engine || '').trim().toLowerCase();
+}
+
 function normalizeRequestedEngines(input) {
   if (!Array.isArray(input)) return [];
   return [...new Set(
     input
-      .map((item) => String(item || '').trim().toLowerCase())
+      .map((item) => normalizeEngineName(item))
       .filter(Boolean)
   )];
 }
 
-function resolveProviderPlan(cfg, requestedEngines = []) {
+function resolveProviderPlan(cfg, requestedEngines = [], category = 'web') {
   const requested = normalizeRequestedEngines(requestedEngines);
   const enabledProviders = Object.keys(PROVIDER_REGISTRY).filter((name) => PROVIDER_REGISTRY[name].enabled(cfg));
+
+  const defaultProviders = enabledProviders.filter((name) => PROVIDER_REGISTRY[name].defaultProvider !== false);
+
   if (requested.length === 0) {
-    return { providers: enabledProviders, searxEngines: [] };
+    return {
+      providers: defaultProviders,
+      searxEngines: category === 'web' && defaultProviders.includes('searxng') ? CURATED_WEB_ENGINES.slice() : [],
+    };
   }
 
   const explicitProviders = new Set();
@@ -96,35 +162,243 @@ function resolveProviderPlan(cfg, requestedEngines = []) {
 
   const providers = [...explicitProviders].filter((name) => enabledProviders.includes(name));
   if (providers.length === 0) {
-    return { providers: enabledProviders, searxEngines: [] };
+    return {
+      providers: defaultProviders,
+      searxEngines: category === 'web' && defaultProviders.includes('searxng') ? CURATED_WEB_ENGINES.slice() : [],
+    };
   }
+
   return { providers, searxEngines };
 }
 
-async function runProvider(name, args) {
+function classifyEngineFailure(reason) {
+  const raw = String(reason || '').toLowerCase();
+  if (!raw) return null;
+  if (raw.includes('captcha')) return 'captcha';
+  if (raw.includes('429') || raw.includes('too many')) return 'too_many_requests';
+  if (raw.includes('403') || raw.includes('access denied')) return 'access_denied';
+  if (raw.includes('timeout') || raw.includes('aborted')) return 'timeout';
+  if (raw.includes('unreachable') || raw.includes('network')) return 'network';
+  return 'other';
+}
+
+function recordEngineOutcome(engine, ok, reason = null) {
+  const key = normalizeEngineName(engine);
+  if (!key) return;
+
+  const entry = ENGINE_HEALTH_STORE.get(key) || {
+    history: [],
+    failureKinds: {},
+    lastFailure: null,
+    updatedAt: 0,
+  };
+
+  entry.history.push(ok ? 1 : 0);
+  if (entry.history.length > ENGINE_HEALTH_HISTORY_LIMIT) entry.history.shift();
+
+  if (!ok && reason) {
+    const kind = classifyEngineFailure(reason) || 'other';
+    entry.failureKinds[kind] = Number(entry.failureKinds[kind] || 0) + 1;
+    entry.lastFailure = kind;
+  }
+
+  entry.updatedAt = Date.now();
+  ENGINE_HEALTH_STORE.set(key, entry);
+}
+
+function getEngineHealth(engine) {
+  const key = normalizeEngineName(engine);
+  const entry = ENGINE_HEALTH_STORE.get(key);
+  if (!entry || entry.history.length === 0) {
+    return { status: 'unknown', samples: 0, successRate: null, penalty: 0, lastFailure: null, failureKinds: {} };
+  }
+
+  const samples = entry.history.length;
+  const successes = entry.history.reduce((sum, v) => sum + v, 0);
+  const successRate = successes / samples;
+
+  if (samples >= 2 && successRate < 0.5) {
+    return {
+      status: 'poor',
+      samples,
+      successRate: Number(successRate.toFixed(2)),
+      penalty: 1.2,
+      lastFailure: entry.lastFailure,
+      failureKinds: entry.failureKinds,
+    };
+  }
+
+  if (successRate < 0.75) {
+    return {
+      status: 'unstable',
+      samples,
+      successRate: Number(successRate.toFixed(2)),
+      penalty: 0.55,
+      lastFailure: entry.lastFailure,
+      failureKinds: entry.failureKinds,
+    };
+  }
+
+  return {
+    status: 'healthy',
+    samples,
+    successRate: Number(successRate.toFixed(2)),
+    penalty: 0,
+    lastFailure: entry.lastFailure,
+    failureKinds: entry.failureKinds,
+  };
+}
+
+function getEngineHealthSummary(engines = []) {
+  const out = {};
+  for (const engine of engines) {
+    const key = normalizeEngineName(engine);
+    if (!key || out[key]) continue;
+    out[key] = getEngineHealth(key);
+  }
+  return out;
+}
+
+function withInflightSearch(key, factory) {
+  if (INFLIGHT_SEARCH_STORE.has(key)) return INFLIGHT_SEARCH_STORE.get(key);
+  const promise = Promise.resolve()
+    .then(factory)
+    .finally(() => {
+      if (INFLIGHT_SEARCH_STORE.get(key) === promise) INFLIGHT_SEARCH_STORE.delete(key);
+    });
+  INFLIGHT_SEARCH_STORE.set(key, promise);
+  return promise;
+}
+
+function normalizeProviderPayload(payload) {
+  if (Array.isArray(payload)) return { results: payload, meta: {} };
+  if (payload && typeof payload === 'object') {
+    return {
+      results: Array.isArray(payload.results) ? payload.results : [],
+      meta: payload._meta || {},
+    };
+  }
+  return { results: [], meta: { error: 'provider_invalid_payload' } };
+}
+
+async function runProviderDetailed(name, args) {
   const provider = PROVIDER_REGISTRY[name];
-  if (!provider) return [];
+  if (!provider) {
+    return {
+      name,
+      results: [],
+      respondedEngines: [],
+      failedEngines: [name],
+      failedDetails: [{ engine: name, reason: 'provider_not_found' }],
+    };
+  }
+
   try {
-    return await provider.run(args);
-  } catch {
-    return [];
+    const payload = normalizeProviderPayload(await provider.run(args));
+    const results = payload.results;
+    const meta = payload.meta || {};
+
+    const responded = new Set();
+    const failed = new Set();
+    const failedDetails = [];
+
+    if (name === 'searxng') {
+      const unresponsive = Array.isArray(meta.unresponsive) ? meta.unresponsive.map((engine) => normalizeEngineName(engine)).filter(Boolean) : [];
+      const unresponsiveDetails = Array.isArray(meta.unresponsiveDetails) ? meta.unresponsiveDetails : [];
+
+      for (const item of results) {
+        const eng = normalizeEngineName(item?.engine);
+        if (!eng || unresponsive.includes(eng)) continue;
+        responded.add(eng);
+      }
+
+      for (const engine of unresponsive) {
+        failed.add(engine);
+        const detail = unresponsiveDetails.find((entry) => normalizeEngineName(entry?.engine) === engine);
+        failedDetails.push({ engine, reason: String(detail?.reason || 'unresponsive') });
+      }
+
+      if (meta.error) {
+        failed.add('searxng');
+        failedDetails.push({ engine: 'searxng', reason: String(meta.error) });
+      }
+    } else if (meta.error) {
+      failed.add(name);
+      failedDetails.push({ engine: name, reason: String(meta.error) });
+    } else {
+      responded.add(name);
+    }
+
+    for (const engine of responded) recordEngineOutcome(engine, true);
+    for (const detail of failedDetails) recordEngineOutcome(detail.engine, false, detail.reason);
+
+    return {
+      name,
+      results,
+      respondedEngines: [...responded],
+      failedEngines: [...failed],
+      failedDetails,
+    };
+  } catch (error) {
+    const reason = String(error?.message || 'provider_failed');
+    recordEngineOutcome(name, false, reason);
+    return {
+      name,
+      results: [],
+      respondedEngines: [],
+      failedEngines: [name],
+      failedDetails: [{ engine: name, reason }],
+    };
   }
 }
 
-// Run a search across all enabled providers and return merged, ranked results
-export async function search({ query, lang = 'en-US', safe = '1', page = 1, category = 'web', engines = [] }, cfg) {
-  if (!_searchCache) throw new Error('Caches not initialized — call initCaches() first');
+function cacheEngineList(providerList, searxEngines = []) {
+  const searx = searxEngines.map((engine) => `searx:${engine}`);
+  return [...providerList, ...searx];
+}
+
+function buildEngineStats(respondedEngines = [], failedEngines = [], failedDetails = []) {
+  const responded = [...new Set(respondedEngines.map((engine) => normalizeEngineName(engine)).filter(Boolean))];
+  const failed = [...new Set(failedEngines.map((engine) => normalizeEngineName(engine)).filter(Boolean))];
+  const details = failedDetails
+    .map((item) => ({
+      engine: normalizeEngineName(item?.engine),
+      reason: String(item?.reason || ''),
+    }))
+    .filter((item) => item.engine);
+
+  const health = getEngineHealthSummary([...responded, ...failed]);
+  const unstable = Object.entries(health)
+    .filter(([, meta]) => meta.status === 'unstable' || meta.status === 'poor')
+    .map(([engine]) => engine)
+    .sort();
+
+  return {
+    responded,
+    failed,
+    failedDetails: details,
+    degraded: failed.length > 0,
+    unstable,
+    health,
+  };
+}
 
-  const plan = resolveProviderPlan(cfg, engines);
+async function runSearchBatch({ query, lang, safe, page, category, engines, cfg }) {
+  const plan = resolveProviderPlan(cfg, engines, category);
   const providerList = plan.providers;
   const timeoutMs = cfg.search.timeout_ms;
-  const cacheEngines = providerList.length ? providerList : ['none'];
-  const cacheKey = searchCacheKey(query, lang, safe, cacheEngines, 'full', category, page);
-  const cached = _searchCache.get(cacheKey);
-  if (cached) return cached;
 
-  const tasks = providerList.map((providerName) =>
-    runProvider(providerName, {
+  if (providerList.length === 0) {
+    return {
+      results: [],
+      providers: [],
+      engineStats: buildEngineStats([], [], []),
+      category,
+    };
+  }
+
+  const runs = await Promise.all(providerList.map((providerName) =>
+    runProviderDetailed(providerName, {
       query,
       lang,
       safe,
@@ -134,39 +408,66 @@ export async function search({ query, lang = 'en-US', safe = '1', page = 1, cate
       timeoutMs,
       engines: providerName === 'searxng' ? plan.searxEngines : [],
     })
-  );
-
-  const allResults = await Promise.all(tasks);
+  ));
 
-  // Merge all provider results
   let merged = [];
-  for (const provResults of allResults) {
-    merged = mergeSearchResultSets(merged, provResults);
-  }
+  const responded = [];
+  const failed = [];
+  const failedDetails = [];
 
-  // Rank by source diversity
-  const ranked = rankResultsBySourceDiversity(merged);
+  for (const run of runs) {
+    merged = mergeSearchResultSets(merged, run.results);
+    responded.push(...run.respondedEngines);
+    failed.push(...run.failedEngines);
+    failedDetails.push(...run.failedDetails);
+  }
 
-  const response = {
-    results: ranked,
-    query,
-    lang,
-    page: Number(page),
-    total: ranked.length,
+  return {
+    results: rankResultsBySourceDiversity(merged),
     providers: providerList,
+    engineStats: buildEngineStats(responded, failed, failedDetails),
     category,
+    searxEngines: plan.searxEngines,
   };
+}
+
+// Run a search across enabled providers and return merged, ranked results
+export async function search({ query, lang = 'en-US', safe = '1', page = 1, category = 'web', engines = [] }, cfg) {
+  if (!_searchCache) throw new Error('Caches not initialized — call initCaches() first');
+
+  const plan = resolveProviderPlan(cfg, engines, category);
+  const cacheEngines = cacheEngineList(plan.providers, plan.searxEngines);
+  const cacheKey = searchCacheKey(query, lang, safe, cacheEngines.length ? cacheEngines : ['none'], 'full', category, page);
+  const cached = _searchCache.get(cacheKey);
+  if (cached) return cached;
+
+  const response = await withInflightSearch(`search:${cacheKey}`, async () => {
+    const fresh = await runSearchBatch({ query, lang, safe, page, category, engines, cfg });
+    return {
+      results: fresh.results,
+      query,
+      lang,
+      page: Number(page),
+      total: fresh.results.length,
+      providers: fresh.providers,
+      category,
+      degraded: fresh.engineStats.degraded,
+      engineStats: fresh.engineStats,
+    };
+  });
 
   _searchCache.set(cacheKey, response, cfg.search.cache_ttl_search_ms);
   return response;
 }
 
-// Streaming search: returns fast results first (DDG), then merges full results
+// Streaming search: returns fast results first, then merged full results
 export async function* searchStream({ query, lang = 'en-US', safe = '1', page = 1, category = 'web', engines = [] }, cfg) {
-  const plan = resolveProviderPlan(cfg, engines);
+  const plan = resolveProviderPlan(cfg, engines, category);
   const providerList = plan.providers;
+
   if (providerList.length === 0) {
-    yield { tier: 'full', results: [], providers: [] };
+    const emptyStats = buildEngineStats([], [], []);
+    yield { tier: 'full', results: [], providers: [], degraded: emptyStats.degraded, engineStats: emptyStats };
     return;
   }
 
@@ -174,7 +475,8 @@ export async function* searchStream({ query, lang = 'en-US', safe = '1', page =
   const fastProvider = providerList.includes('duckduckgo')
     ? 'duckduckgo'
     : providerList[0];
-  const fastResults = await runProvider(fastProvider, {
+
+  const fastRun = await runProviderDetailed(fastProvider, {
     query,
     lang,
     safe,
@@ -184,13 +486,23 @@ export async function* searchStream({ query, lang = 'en-US', safe = '1', page =
     timeoutMs,
     engines: fastProvider === 'searxng' ? plan.searxEngines : [],
   });
-  if (fastResults.length > 0) {
-    yield { tier: 'fast', results: rankResultsBySourceDiversity(fastResults), providers: [fastProvider] };
+
+  const fastRanked = rankResultsBySourceDiversity(fastRun.results);
+  const fastStats = buildEngineStats(fastRun.respondedEngines, fastRun.failedEngines, fastRun.failedDetails);
+
+  if (fastRanked.length > 0) {
+    yield {
+      tier: 'fast',
+      results: fastRanked,
+      providers: [fastProvider],
+      degraded: fastStats.degraded,
+      engineStats: fastStats,
+    };
   }
 
   const remainingProviders = providerList.filter((name) => name !== fastProvider);
-  const tasks = remainingProviders.map((providerName) =>
-    runProvider(providerName, {
+  const additionalRuns = await Promise.all(remainingProviders.map((providerName) =>
+    runProviderDetailed(providerName, {
       query,
       lang,
       safe,
@@ -200,26 +512,44 @@ export async function* searchStream({ query, lang = 'en-US', safe = '1', page =
       timeoutMs,
       engines: providerName === 'searxng' ? plan.searxEngines : [],
     })
-  );
+  ));
 
-  const additional = await Promise.all(tasks);
-  let full = fastResults.slice();
-  for (const r of additional) {
-    full = mergeSearchResultSets(full, r);
+  let full = fastRun.results.slice();
+  const responded = [...fastRun.respondedEngines];
+  const failed = [...fastRun.failedEngines];
+  const failedDetails = [...fastRun.failedDetails];
+
+  for (const run of additionalRuns) {
+    full = mergeSearchResultSets(full, run.results);
+    responded.push(...run.respondedEngines);
+    failed.push(...run.failedEngines);
+    failedDetails.push(...run.failedDetails);
   }
+
   const fullRanked = rankResultsBySourceDiversity(full);
+  const engineStats = buildEngineStats(responded, failed, failedDetails);
 
-  // Cache the full result
-  const cacheEngines = providerList.length ? providerList : ['none'];
-  const cacheKey = searchCacheKey(query, lang, safe, cacheEngines, 'full', category, page);
+  const cacheEngines = cacheEngineList(providerList, plan.searxEngines);
+  const cacheKey = searchCacheKey(query, lang, safe, cacheEngines.length ? cacheEngines : ['none'], 'full', category, page);
   _searchCache?.set(cacheKey, {
     results: fullRanked,
-    query, lang, page: Number(page), total: fullRanked.length,
+    query,
+    lang,
+    page: Number(page),
+    total: fullRanked.length,
     providers: providerList,
     category,
+    degraded: engineStats.degraded,
+    engineStats,
   }, cfg.search.cache_ttl_search_ms);
 
-  yield { tier: 'full', results: fullRanked, providers: providerList };
+  yield {
+    tier: 'full',
+    results: fullRanked,
+    providers: providerList,
+    degraded: engineStats.degraded,
+    engineStats,
+  };
 }
 
 export function getEnabledProviders(cfg) {
@@ -227,5 +557,6 @@ export function getEnabledProviders(cfg) {
   if (cfg.brave?.enabled && cfg.brave?.api_key) providers.push('brave');
   if (cfg.mojeek?.enabled && cfg.mojeek?.api_key) providers.push('mojeek');
   if (cfg.searxng?.enabled && cfg.searxng?.url) providers.push('searxng');
+  providers.push('github-api');
   return providers;
 }

package/src/search/providers/github.js

@@ -0,0 +1,91 @@
+// GitHub Search API provider — optional fallback when SearXNG is unavailable.
+// Works without token (rate-limited by GitHub); token can be set with TERMSEARCH_GITHUB_TOKEN.
+
+const GITHUB_API = 'https://api.github.com';
+
+function buildHeaders(config = {}) {
+  const token = process.env.TERMSEARCH_GITHUB_TOKEN || config?.github?.api_key || '';
+  const headers = {
+    Accept: 'application/vnd.github+json',
+    'User-Agent': 'TermSearch/1.0',
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return headers;
+}
+
+async function fetchJson(url, { headers, timeoutMs = 12000 }) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { headers, signal: ac.signal });
+    if (!response.ok) {
+      const body = await response.text().catch(() => '');
+      throw new Error(`github_http_${response.status}:${body.slice(0, 140)}`);
+    }
+    return response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function mapRepo(item) {
+  const stars = Number(item?.stargazers_count || 0);
+  const forks = Number(item?.forks_count || 0);
+  const lang = String(item?.language || '').trim();
+  const desc = String(item?.description || '').trim();
+  const metaParts = [];
+  if (lang) metaParts.push(lang);
+  metaParts.push(`★ ${stars}`);
+  metaParts.push(`forks ${forks}`);
+  const meta = metaParts.join(' · ');
+  return {
+    title: item?.full_name || item?.name || 'GitHub repository',
+    url: item?.html_url || '',
+    snippet: desc ? `${desc}${meta ? ` — ${meta}` : ''}` : meta,
+    engine: 'github-api',
+    score: 1.0 + Math.min(stars / 10000, 1.0),
+    publishedDate: item?.updated_at || item?.pushed_at || null,
+  };
+}
+
+function mapUser(item) {
+  return {
+    title: item?.login ? `@${item.login} · GitHub` : 'GitHub user',
+    url: item?.html_url || '',
+    snippet: item?.type ? `${item.type} profile on GitHub` : 'GitHub profile',
+    engine: 'github-api',
+    score: 0.8,
+    publishedDate: null,
+  };
+}
+
+export async function search({ query, page = 1, config, timeoutMs = 12000 }) {
+  const q = String(query || '').trim();
+  if (!q) return [];
+
+  const headers = buildHeaders(config);
+  const pageNo = Math.max(1, Number(page) || 1);
+  const repoParams = new URLSearchParams({
+    q,
+    per_page: '8',
+    page: String(pageNo),
+    sort: 'stars',
+    order: 'desc',
+  });
+  const usersParams = new URLSearchParams({
+    q,
+    per_page: '4',
+    page: String(pageNo),
+    sort: 'followers',
+    order: 'desc',
+  });
+
+  const [reposData, usersData] = await Promise.all([
+    fetchJson(`${GITHUB_API}/search/repositories?${repoParams.toString()}`, { headers, timeoutMs }),
+    fetchJson(`${GITHUB_API}/search/users?${usersParams.toString()}`, { headers, timeoutMs }),
+  ]);
+
+  const repos = Array.isArray(reposData?.items) ? reposData.items.map(mapRepo).filter((r) => r.url) : [];
+  const users = Array.isArray(usersData?.items) ? usersData.items.map(mapUser).filter((u) => u.url) : [];
+  return [...repos, ...users];
+}