weavatrix 0.1.0

package/src/infra/infra-items.js

@@ -0,0 +1,255 @@
+// infra-items.js — extract concrete infra items (DB tables, cache keysets, queue topics, cloud files, SQL
+// tables, env-declared endpoints) from source text for the detected services. Split out of infra.js; it owns
+// the shared leaf helpers (lc/safeRead/size caps) as the lower module — infra.js imports them back.
+import { safeRead, MAX_FILE_BYTES } from "../util.js";
+
+const IMPORT_SCAN_MAX_FILES = 2000; // cap the synchronous import-scan pass (connector attribution only) so the
+const lc = (s) => String(s || "").toLowerCase();
+
+export { safeRead };
+
+const ITEM_META = {
+  db: { label: "TABLES", unit: "rows" },
+  ts: { label: "SERIES", unit: "pts" },
+  cache: { label: "KEYSETS", unit: "keys" },
+  queue: { label: "TOPICS", unit: "msg/s" },
+  cloud: { label: "FILES", unit: "KB" },
+  fs: { label: "FILES", unit: "KB" },
+  logs: { label: "STREAMS", unit: "l/s" },
+  api: { label: "ENDPOINTS", unit: "req/s" },
+};
+const ITEM_VALUE = { db: 42, ts: 120, cache: 700, queue: 22, cloud: 120, fs: 80, logs: 55, api: 24 };
+const SQL_RESERVED = new Set([
+  "select", "from", "where", "join", "left", "right", "inner", "outer", "full", "cross",
+  "on", "and", "or", "by", "group", "order", "limit", "offset", "as", "with", "values",
+  "set", "returning", "true", "false", "null", "undefined", "if", "case", "when", "then",
+  "else", "end", "having", "over", "partition", "distinct", "the", "is",
+  "count", "sum", "avg", "min", "max", "uniq", "array", "date", "datetime", "string", "number",
+]);
+
+export function itemMetaFor(service) {
+  if (service.id === "mongodb") return { label: "COLLECTIONS", unit: "docs" };
+  if (service.id === "dynamodb") return { label: "TABLES", unit: "items" };
+  if (service.id === "elasticsearch" || service.id === "solr" || service.id === "meilisearch" || service.id === "typesense") {
+    return { label: "INDEXES", unit: "docs" };
+  }
+  return ITEM_META[service.kind] || { label: "ITEMS", unit: "" };
+}
+
+function cleanInfraItemName(raw) {
+  const name = String(raw || "").trim().replace(/^(?:["'`]|\[)+|(?:["'`]|])+$/g, "").replace(/[;,]+$/g, "").trim();
+  if (!name || name.length < 2 || name.length > 64) return "";
+  if (name.includes("://") || name.includes("${") || name.includes("#{")) return "";
+  if (/[\s(){}+$]/.test(name)) return "";
+  if (!/^[A-Za-z0-9_./:\-*]+$/.test(name)) return "";
+  if (/^\d+$/.test(name) || SQL_RESERVED.has(name.toLowerCase())) return "";
+  return name;
+}
+
+function addInfraItem(map, raw, weight = 1, sourcePath = "", op = "") {
+  const name = cleanInfraItemName(raw);
+  if (!name) return;
+  const cur = map.get(name) || { name, refs: 0, files: new Set(), ops: new Set() };
+  cur.refs += Math.max(1, weight);
+  if (sourcePath) cur.files.add(sourcePath);
+  if (op) cur.ops.add(op);
+  map.set(name, cur);
+}
+
+// One regex-walk adder factory shared by the two matchers below — the only difference is how a
+// captured group becomes items (a single name vs a string-array body).
+const matchAdder = (add) => (map, text, re, group = 1, weight = 1, sourcePath = "", op = "") => {
+  for (const m of text.matchAll(re)) add(map, m[group], weight, sourcePath, op);
+};
+
+function addStringArrayItems(map, raw, weight = 1, sourcePath = "", op = "") {
+  const body = String(raw || "");
+  for (const m of body.matchAll(/["'`]([^"'`]+)["'`]/g)) addInfraItem(map, m[1], weight, sourcePath, op);
+}
+
+const addMatches = matchAdder(addInfraItem);
+const addStructArrayMatches = matchAdder(addStringArrayItems);
+
+function addSqlTableMatches(map, text, re, cteAliases, group = 1, weight = 1, sourcePath = "", op = "") {
+  for (const m of String(text || "").matchAll(re)) {
+    const name = String(m[group] || "");
+    if (cteAliases.has(name.toLowerCase())) continue;
+    addInfraItem(map, name, weight, sourcePath, op);
+  }
+}
+
+function looksLikeSqlSnippet(raw) {
+  const text = String(raw || "").replace(/\$\{[\s\S]*?\}/g, " ");
+  if (!/[A-Za-z]/.test(text)) return false;
+  const statementStart = "(?:^|[\\r\\n;])\\s*";
+  return (
+    new RegExp(`${statementStart}(?:select|with)\\b[\\s\\S]{0,600}\\bfrom\\b`, "i").test(text) ||
+    new RegExp(`${statementStart}(?:insert\\s+into|delete\\s+from|alter\\s+table|create\\s+(?:or\\s+replace\\s+)?table|truncate\\s+table|update\\s+["'\`\\[]?[A-Za-z_][\\w$]*(?:\\.[A-Za-z_][\\w$]*)?["'\`\\]]?\\s+set)\\b`, "i").test(text)
+  );
+}
+
+function stringLiteralBody(match) {
+  for (let i = 1; i < match.length; i++) if (match[i] != null) return match[i];
+  return "";
+}
+
+function extractSqlSnippets(text) {
+  const out = [];
+  const src = String(text || "");
+  const add = (body) => {
+    const snippet = String(body || "");
+    if (looksLikeSqlSnippet(snippet)) out.push(snippet);
+  };
+
+  for (const match of src.matchAll(/"""([\s\S]*?)"""|'''([\s\S]*?)'''/g)) add(stringLiteralBody(match));
+  for (const match of src.matchAll(/`([\s\S]*?)`|"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'/g)) add(stringLiteralBody(match));
+  return out.join("\n");
+}
+
+function sqlCteAliases(text) {
+  const out = new Set();
+  for (const match of String(text || "").matchAll(/(?:\bwith|,)\s+([A-Za-z_][\w$]*)\s+as\s*\(/gi)) {
+    out.add(String(match[1] || "").toLowerCase());
+  }
+  return out;
+}
+
+function hasServiceHint(service, text) {
+  const lower = lc(text);
+  const tokens = [service.id, service.name, ...(service.imports || []), ...(service.deps || [])]
+    .map((x) => lc(x))
+    .filter((x) => x && x.length > 2);
+  return tokens.some((token) => lower.includes(token));
+}
+
+function finalizeInfraItems(map, kind) {
+  const base = ITEM_VALUE[kind] || 40;
+  return [...map.values()]
+    .sort((a, b) => b.refs - a.refs || a.name.localeCompare(b.name))
+    .slice(0, 24)
+    .map((item) => ({
+      name: item.name,
+      val: Math.round(Math.max(4, base * (1 + Math.log2(item.refs + 1) * 0.55))),
+      health: Math.max(0.42, Math.min(0.96, 0.94 - Math.log2(item.refs + 1) * 0.08)),
+      refs: item.refs,
+      fileCount: item.files ? item.files.size : 0,
+      files: item.files ? [...item.files].sort().slice(0, 12) : [],
+      ops: item.ops ? [...item.ops].sort().slice(0, 12) : [],
+    }));
+}
+
+function extractInfraItemsForService(service, text, out, sourcePath = "") {
+  const id = service.id;
+  const kind = service.kind;
+  const hit = (re, group = 1, weight = 1, op = "") => addMatches(out, text, re, group, weight, sourcePath, op);
+  const hitSql = (target, re, cteAliases, group = 1, weight = 1, op = "") => addSqlTableMatches(out, target, re, cteAliases, group, weight, sourcePath, op);
+  const hitArrays = (re, group = 1, weight = 1, op = "") => addStructArrayMatches(out, text, re, group, weight, sourcePath, op);
+  // Go/CLI services often carry their topics/keyspaces as FLAG DEFAULTS, not literals at the call
+  // site (bgp-speaker: flag.String("bgp_update_kafka_topic", "bgp_updates", …), flag.String(
+  // "redis_key_base", "bgp:mitigators", …)) — the flag NAME says what the default VALUE is.
+  const hitFlagDefaults = (nameRe, weight = 2, op = "configured") => {
+    for (const m of text.matchAll(/\b(?:flag|pflag)\.String(?:Var)?\s*\(\s*(?:&[\w.]+\s*,\s*)?"([^"]+)"\s*,\s*"([^"]+)"/g)) {
+      if (nameRe.test(m[1])) addInfraItem(out, m[2], weight, sourcePath, op);
+    }
+    for (const m of text.matchAll(/\badd_argument\s*\(\s*["']--?([^"']+)["'][^)]{0,200}?\bdefault\s*=\s*["']([^"']+)["']/g)) {
+      if (nameRe.test(m[1])) addInfraItem(out, m[2], weight, sourcePath, op);
+    }
+  };
+
+  if (id === "mongodb") {
+    hit(/\.collection\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi, 1, 2);
+    hit(/\.Collection\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g, 1, 2);
+    hit(/\bgetCollection\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi, 1, 2);
+    hit(/\bcollection\s*:\s*["'`]([^"'`]+)["'`]/gi);
+    hit(/\b(?:mongoose\.)?model\s*\(\s*["'`]([^"'`]+)["'`]/gi);
+    hit(/\bdb\s*\[\s*["'`]([^"'`]+)["'`]\s*\]/gi);
+    return;
+  }
+
+  if (id === "dynamodb") {
+    hit(/\bTableName\s*:\s*["'`]([^"'`]+)["'`]/g, 1, 2);
+    hit(/\btableName\s*[:=]\s*["'`]([^"'`]+)["'`]/g, 1, 2);
+  }
+
+  if (id === "elasticsearch" || id === "solr" || id === "meilisearch" || id === "typesense") {
+    hit(/\bindex(?:Name)?\s*[:=]\s*["'`]([^"'`]+)["'`]/gi, 1, 2);
+    hit(/\.index\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi, 1, 2);
+  }
+
+  if (kind === "db" || kind === "ts") {
+    const sqlText = extractSqlSnippets(text);
+    if (sqlText) {
+      const cteAliases = sqlCteAliases(sqlText);
+      hitSql(sqlText, /\b(?:insert\s+into|delete\s+from|alter\s+table|create\s+(?:or\s+replace\s+)?table|truncate\s+table)\s+(?:["'`]|\[)?([A-Za-z_][\w$]*(?:\.[A-Za-z_][\w$]*)?)(?:["'`]|])?/gi, cteAliases, 1, 2);
+      hitSql(sqlText, /\b(?:from|join|into|update|table)\s+(?:["'`]|\[)?([A-Za-z_][\w$]*(?:\.[A-Za-z_][\w$]*)?)(?:["'`]|])?/gi, cteAliases);
+    }
+    if (id !== "clickhouse" && hasServiceHint(service, text)) {
+      hit(/\b(?:table|tableName|measurement|bucket)\s*[:=]\s*["'`]([^"'`]+)["'`]/gi);
+    }
+  }
+
+  if (kind === "cache") {
+    hit(/\b(?:get|getBuffer|getdel|exists|ttl|pttl)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 1, "read");
+    hit(/\b(?:set|setex|psetex|setnx|incr|decr|expire|persist)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 2, "write");
+    hit(/\b(?:del|delete|unlink|expireat|pexpireat)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 2, "delete");
+    hit(/\b(?:hget|hmget|hgetall|hexists)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 1, "hash read");
+    hit(/\b(?:hset|hmset|hdel)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 2, "hash write");
+    hit(/\b(?:lpush|rpush|lpop|rpop|sadd|srem|zadd|zrem)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 2, "collection");
+    hit(/\b(?:xadd|xread|xreadgroup|xgroup)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 2, "stream");
+    hit(/\b(?:publish|subscribe|psubscribe)\s*\(\s*(?:ctx\s*,\s*)?["'`]([^"'`]+)["'`]/gi, 1, 1, "pub/sub");
+    hit(/\b(?:cacheKey|redisKey|valkeyKey|redisPrefix|valkeyPrefix|keyPrefix|lockKey|rateLimitKey|sessionKey)\s*[:=]\s*["'`]([^"'`]+)["'`]/gi, 1, 2, "key pattern");
+    hitArrays(/\b(?:Streams|streams)\s*:\s*\[\]string\s*\{([^}]+)\}/g, 1, 2, "stream");
+    hitFlagDefaults(/key|keyspace|prefix/i, 2, "key pattern");
+  }
+
+  if (kind === "queue") {
+    hit(/\b(?:topic|topics|queue|subject|stream|channel|Topic|Queue|Subject|Stream|Channel)\s*[:=]\s*["'`]([^"'`]+)["'`]/g, 1, 2, "configured");
+    hit(/\b(?:publish|produce|send|sendMessage|writeMessage|writeMessages|emit)\s*\(\s*["'`]([^"'`]+)["'`]/gi, 1, 2, "produce");
+    hit(/\b(?:subscribe|consume|consumer|listen|readMessage|readMessages)\s*\(\s*["'`]([^"'`]+)["'`]/gi, 1, 1, "consume");
+    hit(/\b(?:producer\.send|sendBatch)\s*\(\s*\{[\s\S]{0,500}?\btopic\s*:\s*["'`]([^"'`]+)["'`]/gi, 1, 2, "produce");
+    hit(/\bconsumer\.subscribe\s*\(\s*\{[\s\S]{0,320}?\btopic\s*:\s*["'`]([^"'`]+)["'`]/gi, 1, 2, "consume");
+    hit(/\b(?:KafkaConsumer|NewConsumer|NewReader|NewWriter|NewTopic)\s*\(\s*["'`]([^"'`]+)["'`]/g, 1, 2, "configured");
+    hit(/@KafkaListener\s*\([^)]*\btopics?\s*=\s*["'`]([^"'`]+)["'`]/g, 1, 2, "consume");
+    hit(/\bkafkaTemplate\.send\s*\(\s*["'`]([^"'`]+)["'`]/g, 1, 2, "produce");
+    hitArrays(/\b(?:topics|Topics|GroupTopics|SubscribeTopics|streams|Streams)\s*[:=]\s*(?:\[\]string)?\s*\{([^}]+)\}/g, 1, 2, "configured");
+    hitArrays(/\b(?:subscribe|Consume|SubscribeTopics)\s*\(\s*(?:ctx\s*,\s*)?\[\]string\s*\{([^}]+)\}/g, 1, 2, "consume");
+    hitFlagDefaults(/topic|queue|subject|stream|channel/i, 2, "configured");
+  }
+
+  if (kind === "cloud" || kind === "fs") {
+    hit(/\b(?:bucket|bucketName|container|containerName)\s*[:=]\s*["'`]([^"'`]+)["'`]/gi, 1, 2);
+  }
+}
+
+export function collectInfraItems(scan, entries, filesByService) {
+  const result = new Map();
+  const allFiles = (scan.codeFiles || []).slice(0, IMPORT_SCAN_MAX_FILES);
+  const textCache = new Map();
+  const readText = (f) => {
+    if (!f || !f.full) return "";
+    if (!textCache.has(f.full)) textCache.set(f.full, safeRead(f.full));
+    return textCache.get(f.full);
+  };
+
+  for (const { service } of entries) {
+    const meta = itemMetaFor(service);
+    const wanted = filesByService.get(service.id);
+    const preferred = wanted && wanted.size ? allFiles.filter((f) => wanted.has(f.path)) : [];
+    const candidateFiles = preferred.length ? [...preferred, ...allFiles.filter((f) => !wanted.has(f.path))] : allFiles;
+    const itemMap = new Map();
+    for (const f of candidateFiles) {
+      const text = readText(f);
+      if (!text) continue;
+      extractInfraItemsForService(service, text, itemMap, f.path);
+    }
+    result.set(service.id, {
+      itemLabel: meta.label,
+      unit: meta.unit,
+      items: finalizeInfraItems(itemMap, service.kind),
+    });
+  }
+  return result;
+}
+
+
+export { MAX_FILE_BYTES, IMPORT_SCAN_MAX_FILES, lc };

package/src/infra/infra-registry.js

@@ -0,0 +1,184 @@
+// Infra signature registry — generated by the infra-signature-registry workflow (parallel research across
+// Node/Python/Go/JVM/Ruby/PHP/.NET/Rust + docker/k8s/env conventions, then adversarial false-positive +
+// coverage + ground-truth verification, then a category-split synthesis). One row per backing service.
+// See main/repos/infra.js for matcher semantics: deps=exact manifest dep, images=path-segment suffix,
+// envPrefixes=KEY prefix (envWeak entries also require an infra suffix), imports=quoted source token.
+// ORMs / AWS-SDK monoliths / instrumentation libs / generic env prefixes were deliberately EXCLUDED as
+// non-attributing. Import tokens are normalized to bare module paths. Edit this file to tune; regenerate
+// by re-running the workflow (.claude/.../infra-signature-registry).
+export const INFRA_SERVICES = [
+  { id: "postgres", name: "POSTGRES", kind: "db", color: 0x4fd1ff,
+    deps: ["pg","pg-promise","postgres","@neondatabase/serverless","psycopg2-binary","asyncpg","github.com/jackc/pgx/v5","org.postgresql:postgresql"],
+    imports: ["pg-promise","@neondatabase/serverless","psycopg2","asyncpg","github.com/lib/pq","github.com/jackc/pgx","org.postgresql","tokio_postgres"], images: ["postgres","bitnami/postgresql","postgis/postgis","supabase/postgres","pgvector/pgvector"], envPrefixes: ["POSTGRES","POSTGRESQL","PGHOST","PGUSER","PGPASSWORD","PGDATABASE","POSTGRES_HOST"], envWeak: [] },
+  { id: "mysql", name: "MYSQL", kind: "db", color: 0x4fc6ff,
+    deps: ["mysql2","pymysql","mysqlclient","aiomysql","asyncmy","github.com/go-sql-driver/mysql","com.mysql:mysql-connector-j","MySqlConnector"],
+    imports: ["mysql2","pymysql","MySQLdb","aiomysql","asyncmy","github.com/go-sql-driver/mysql","com.mysql.cj","mysql_async"], images: ["mysql","bitnami/mysql","mysql/mysql-server","percona"], envPrefixes: ["MYSQL_HOST","MYSQL_PORT","MYSQL_USER","MYSQL_PASSWORD","MYSQL_DATABASE","MYSQL_ROOT_PASSWORD"], envWeak: [] },
+  { id: "mariadb", name: "MARIADB", kind: "db", color: 0x4fbfe6,
+    deps: ["mariadb","org.mariadb.jdbc:mariadb-java-client","org.mariadb:r2dbc-mariadb"],
+    imports: ["mariadb","org.mariadb.jdbc","org.mariadb.r2dbc"], images: ["mariadb","bitnami/mariadb"], envPrefixes: ["MARIADB_HOST","MARIADB_USER","MARIADB_PASSWORD","MARIADB_DATABASE","MARIADB_ROOT_PASSWORD"], envWeak: [] },
+  { id: "sqlserver", name: "SQLSERVER", kind: "db", color: 0x5fb0ff,
+    deps: ["mssql","tedious","pymssql","github.com/microsoft/go-mssqldb","com.microsoft.sqlserver:mssql-jdbc","tiberius","io.r2dbc:r2dbc-mssql"],
+    imports: ["mssql","tedious","pymssql","github.com/microsoft/go-mssqldb","com.microsoft.sqlserver.jdbc","tiberius","io.r2dbc.mssql"], images: ["mcr.microsoft.com/mssql/server","mcr.microsoft.com/azure-sql-edge"], envPrefixes: ["MSSQL_HOST","MSSQL_SA_PASSWORD","SQLSERVER_HOST","SQL_SERVER"], envWeak: [] },
+  { id: "sqlite", name: "SQLITE", kind: "db", color: 0x6fb8ff,
+    deps: ["better-sqlite3","sqlite3","aiosqlite","@libsql/client","github.com/mattn/go-sqlite3","org.xerial:sqlite-jdbc","rusqlite","modernc.org/sqlite"],
+    imports: ["better-sqlite3","sqlite3","aiosqlite","@libsql/client","github.com/mattn/go-sqlite3","org.sqlite","rusqlite","node:sqlite"], images: [], envPrefixes: ["SQLITE_PATH","TURSO","LIBSQL"], envWeak: [] },
+  { id: "cockroachdb", name: "COCKROACHDB", kind: "db", color: 0x4fd9d1,
+    deps: ["github.com/cockroachdb/cockroach-go/v2","sqlalchemy-cockroachdb"],
+    imports: ["github.com/cockroachdb/cockroach-go","sqlalchemy_cockroachdb"], images: ["cockroachdb/cockroach","bitnami/cockroachdb"], envPrefixes: ["COCKROACH","COCKROACHDB","CRDB_HOST","COCKROACH_URL"], envWeak: [] },
+  { id: "spanner", name: "SPANNER", kind: "db", color: 0x4fd1e0,
+    deps: ["cloud.google.com/go/spanner","com.google.cloud:google-cloud-spanner","com.google.cloud:google-cloud-spanner-jdbc"],
+    imports: ["cloud.google.com/go/spanner","com.google.cloud.spanner"], images: ["gcr.io/cloud-spanner-emulator/emulator"], envPrefixes: ["SPANNER"], envWeak: [] },
+  { id: "planetscale", name: "PLANETSCALE", kind: "db", color: 0x6fd1ff,
+    deps: ["@planetscale/database"],
+    imports: ["@planetscale/database"], images: ["vitess/vtgate","vitess/lite"], envPrefixes: ["PLANETSCALE","DATABASE_HOST","PSCALE"], envWeak: [] },
+  { id: "snowflake", name: "SNOWFLAKE", kind: "db", color: 0x4fb6ff,
+    deps: ["snowflake-sdk","snowflake-connector-python","github.com/snowflakedb/gosnowflake","net.snowflake:snowflake-jdbc","Snowflake.Data"],
+    imports: ["snowflake-sdk","snowflake.connector","github.com/snowflakedb/gosnowflake","net.snowflake.client","Snowflake.Data"], images: [], envPrefixes: ["SNOWFLAKE_ACCOUNT","SNOWFLAKE_USER","SNOWFLAKE_WAREHOUSE","SNOWFLAKE_DATABASE"], envWeak: [] },
+  { id: "bigquery", name: "BIGQUERY", kind: "db", color: 0x5fc0ff,
+    deps: ["@google-cloud/bigquery","google-cloud-bigquery","cloud.google.com/go/bigquery","com.google.cloud:google-cloud-bigquery"],
+    imports: ["@google-cloud/bigquery","google.cloud.bigquery","cloud.google.com/go/bigquery","com.google.cloud.bigquery"], images: ["ghcr.io/goccy/bigquery-emulator"], envPrefixes: ["BIGQUERY","GOOGLE_BIGQUERY"], envWeak: [] },
+  { id: "redshift", name: "REDSHIFT", kind: "db", color: 0x4fa8ff,
+    deps: ["@aws-sdk/client-redshift","@aws-sdk/client-redshift-data","redshift-connector","com.amazon.redshift:redshift-jdbc42"],
+    imports: ["@aws-sdk/client-redshift","redshift_connector","com.amazon.redshift"], images: [], envPrefixes: ["REDSHIFT_HOST","REDSHIFT_URL","REDSHIFT_CLUSTER"], envWeak: [] },
+  { id: "db2", name: "DB2", kind: "db", color: 0x4fcfff,
+    deps: ["com.ibm.db2:jcc","com.ibm.db2.jcc:db2jcc","ibm_db"],
+    imports: ["com.ibm.db2.jcc","ibm_db"], images: ["ibmcom/db2","icr.io/db2_community/db2"], envPrefixes: ["DB2"], envWeak: ["DB2"] },
+  { id: "mongodb", name: "MONGODB", kind: "db", color: 0x6fe26f,
+    deps: ["mongodb","mongoose","pymongo","motor","go.mongodb.org/mongo-driver","org.mongodb:mongodb-driver-sync","org.mongodb:mongo-java-driver","MongoDB.Driver"],
+    imports: ["mongoose","pymongo","motor.motor_asyncio","go.mongodb.org/mongo-driver/mongo","com.mongodb.","mongodb","Mongo::Client"], images: ["mongo","bitnami/mongodb","percona/percona-server-mongodb","mongodb/mongodb-community-server"], envPrefixes: ["MONGO","MONGODB","MONGO_URI","MONGO_HOST","MONGODB_URI"], envWeak: [] },
+  { id: "cassandra", name: "CASSANDRA", kind: "db", color: 0x66dd66,
+    deps: ["cassandra-driver","github.com/gocql/gocql","com.datastax.oss:java-driver-core","com.datastax.cassandra:cassandra-driver-core","CassandraCSharpDriver","scylla-driver","acsylla","cdrs-tokio"],
+    imports: ["cassandra-driver","github.com/gocql/gocql","com.datastax.oss.driver","com.datastax.driver.core","scylla"], images: ["cassandra","bitnami/cassandra","scylladb/scylla","scylladb/scylla-enterprise"], envPrefixes: ["CASSANDRA","SCYLLA","CASSANDRA_CONTACT_POINTS","CASSANDRA_KEYSPACE","SCYLLA_CONTACT_POINTS"], envWeak: [] },
+  { id: "dynamodb", name: "DYNAMODB", kind: "db", color: 0x5fd95f,
+    deps: ["@aws-sdk/client-dynamodb","@aws-sdk/lib-dynamodb","dynamoose","electrodb","pynamodb","github.com/aws/aws-sdk-go-v2/service/dynamodb","software.amazon.awssdk:dynamodb","github.com/guregu/dynamo"],
+    imports: ["@aws-sdk/client-dynamodb","@aws-sdk/lib-dynamodb","dynamoose","pynamodb","github.com/aws/aws-sdk-go-v2/service/dynamodb","software.amazon.awssdk.services.dynamodb","Amazon.DynamoDBv2"], images: ["amazon/dynamodb-local"], envPrefixes: ["DYNAMODB","DYNAMO","DYNAMODB_TABLE","DYNAMODB_ENDPOINT","AWS_DYNAMODB"], envWeak: [] },
+  { id: "elasticsearch", name: "ELASTICSEARCH", kind: "db", color: 0x7aea7a,
+    deps: ["@elastic/elasticsearch","@opensearch-project/opensearch","elasticsearch","elasticsearch-dsl","opensearch-py","github.com/elastic/go-elasticsearch","co.elastic.clients:elasticsearch-java","org.opensearch.client:opensearch-java"],
+    imports: ["@elastic/elasticsearch","@opensearch-project/opensearch","elasticsearch_dsl","opensearchpy","github.com/elastic/go-elasticsearch","co.elastic.clients.elasticsearch","org.opensearch.client"], images: ["elasticsearch","docker.elastic.co/elasticsearch/elasticsearch","bitnami/elasticsearch","opensearchproject/opensearch"], envPrefixes: ["ELASTICSEARCH","OPENSEARCH","ES_HOST","ES_URL","ELASTICSEARCH_URL","OPENSEARCH_URL"], envWeak: [] },
+  { id: "solr", name: "SOLR", kind: "db", color: 0x63e063,
+    deps: ["solr-client","solr-node","pysolr","aiosolr","github.com/vanng822/go-solr","org.apache.solr:solr-solrj"],
+    imports: ["solr-client","solr-node","pysolr","org.apache.solr.client.solrj","org.springframework.data.solr"], images: ["solr","bitnami/solr"], envPrefixes: ["SOLR","SOLR_HOST","SOLR_URL","SOLR_PORT"], envWeak: [] },
+  { id: "meilisearch", name: "MEILISEARCH", kind: "db", color: 0x72e672,
+    deps: ["meilisearch","@meilisearch/instant-meilisearch","meilisearch-python-sdk","github.com/meilisearch/meilisearch-go","com.meilisearch.sdk:meilisearch-java"],
+    imports: ["meilisearch","@meilisearch/instant-meilisearch","github.com/meilisearch/meilisearch-go","com.meilisearch.sdk"], images: ["getmeili/meilisearch"], envPrefixes: ["MEILI","MEILISEARCH","MEILI_HOST","MEILI_MASTER_KEY","MEILISEARCH_URL"], envWeak: [] },
+  { id: "typesense", name: "TYPESENSE", kind: "db", color: 0x59d959,
+    deps: ["typesense","typesense-instantsearch-adapter","typesense-python","github.com/typesense/typesense-go"],
+    imports: ["typesense","typesense-instantsearch-adapter","github.com/typesense/typesense-go"], images: ["typesense/typesense"], envPrefixes: ["TYPESENSE","TYPESENSE_HOST","TYPESENSE_API_KEY","TYPESENSE_URL"], envWeak: [] },
+  { id: "neo4j", name: "NEO4J", kind: "db", color: 0x6fe28a,
+    deps: ["neo4j-driver","neo4j","py2neo","neomodel","github.com/neo4j/neo4j-go-driver","org.neo4j.driver:neo4j-java-driver","neo4rs","@neo4j/graphql"],
+    imports: ["neo4j-driver","py2neo","neomodel","github.com/neo4j/neo4j-go-driver","org.neo4j.driver","neo4rs"], images: ["neo4j","bitnami/neo4j"], envPrefixes: ["NEO4J","NEO4J_URI","NEO4J_HOST","NEO4J_AUTH"], envWeak: [] },
+  { id: "couchbase", name: "COUCHBASE", kind: "db", color: 0x6fe27a,
+    deps: ["couchbase","acouchbase","github.com/couchbase/gocb/v2","com.couchbase.client:java-client","couchbase-rs"],
+    imports: ["couchbase","acouchbase","github.com/couchbase/gocb","com.couchbase.client"], images: ["couchbase","bitnami/couchbase"], envPrefixes: ["COUCHBASE","COUCHBASE_HOST","COUCHBASE_URL","COUCHBASE_BUCKET"], envWeak: [] },
+  { id: "qdrant", name: "QDRANT", kind: "db", color: 0x86e886,
+    deps: ["@qdrant/js-client-rest","@qdrant/qdrant-js","qdrant-client","github.com/qdrant/go-client","io.qdrant:client"],
+    imports: ["@qdrant/js-client-rest","qdrant_client","github.com/qdrant/go-client","io.qdrant.client"], images: ["qdrant/qdrant"], envPrefixes: ["QDRANT","QDRANT_URL","QDRANT_HOST","QDRANT_API_KEY"], envWeak: [] },
+  { id: "weaviate", name: "WEAVIATE", kind: "db", color: 0x90ee90,
+    deps: ["weaviate-client","weaviate-ts-client","weaviate-python-client","github.com/weaviate/weaviate-go-client","io.weaviate:client"],
+    imports: ["weaviate-client","weaviate-ts-client","github.com/weaviate/weaviate-go-client","io.weaviate.client"], images: ["semitechnologies/weaviate","cr.weaviate.io/semitechnologies/weaviate"], envPrefixes: ["WEAVIATE","WEAVIATE_URL","WEAVIATE_HOST","WEAVIATE_API_KEY"], envWeak: [] },
+  { id: "milvus", name: "MILVUS", kind: "db", color: 0x9cf09c,
+    deps: ["@zilliz/milvus2-sdk-node","pymilvus","github.com/milvus-io/milvus-sdk-go","io.milvus:milvus-sdk-java"],
+    imports: ["@zilliz/milvus2-sdk-node","pymilvus","github.com/milvus-io/milvus-sdk-go","io.milvus."], images: ["milvusdb/milvus","zilliz/milvus"], envPrefixes: ["MILVUS","MILVUS_HOST","MILVUS_URL","MILVUS_PORT"], envWeak: [] },
+  { id: "clickhouse", name: "CLICKHOUSE", kind: "ts", color: 0xffe14f,
+    deps: ["@clickhouse/client","@clickhouse/client-web","clickhouse-driver","clickhouse-connect","github.com/ClickHouse/clickhouse-go/v2","com.clickhouse:clickhouse-jdbc","com.clickhouse:clickhouse-client","ClickHouse.Client","clickhouse"],
+    imports: ["@clickhouse/client","clickhouse_driver","clickhouse_connect","github.com/ClickHouse/clickhouse-go","com.clickhouse.","ru.yandex.clickhouse","clickhouse","Octonica.ClickHouseClient"], images: ["clickhouse/clickhouse-server","clickhouse/clickhouse-keeper","bitnami/clickhouse","yandex/clickhouse-server"], envPrefixes: ["CLICKHOUSE","CH_HOST","CH_PORT","CH_PASSWORD"], envWeak: [] },
+  { id: "influxdb", name: "INFLUXDB", kind: "ts", color: 0xf5d800,
+    deps: ["@influxdata/influxdb-client","influxdb-client","github.com/influxdata/influxdb-client-go/v2","com.influxdb:influxdb-client-java","org.influxdb:influxdb-java","influxdb3-python","influxdb2","InfluxDB.Client","influx"],
+    imports: ["@influxdata/influxdb-client","influxdb_client","github.com/influxdata/influxdb-client-go","github.com/influxdata/influxdb1-client","com.influxdb.client","org.influxdb.","influx","influxdb"], images: ["influxdb","bitnami/influxdb","quay.io/influxdb/influxdb","telegraf"], envPrefixes: ["INFLUX","INFLUXDB","INFLUX_TOKEN","INFLUXDB_URL","INFLUX_ORG","INFLUX_BUCKET"], envWeak: [] },
+  { id: "timescaledb", name: "TIMESCALEDB", kind: "ts", color: 0xffea66,
+    deps: ["@timescale/toolkit"],
+    imports: ["@timescale/toolkit"], images: ["timescale/timescaledb","timescale/timescaledb-ha","timescaledev/timescaledb-ha"], envPrefixes: ["TIMESCALE","TIMESCALEDB"], envWeak: [] },
+  { id: "prometheus", name: "PROMETHEUS", kind: "ts", color: 0xfff04d,
+    deps: ["prometheus-query","prometheus-api-client","github.com/prometheus/client_golang/api"],
+    imports: ["prometheus-query","github.com/prometheus/client_golang/api","prometheus_api_client"], images: ["prom/prometheus","prom/pushgateway","bitnami/prometheus","prom/node-exporter"], envPrefixes: ["PROMETHEUS","PROMETHEUS_URL","PUSHGATEWAY"], envWeak: [] },
+  { id: "victoriametrics", name: "VICTORIAMETRICS", kind: "ts", color: 0xe6d633,
+    deps: ["github.com/VictoriaMetrics/VictoriaMetrics"],
+    imports: ["github.com/VictoriaMetrics/VictoriaMetrics"], images: ["victoriametrics/victoria-metrics","victoriametrics/vmagent","victoriametrics/vminsert","victoriametrics/vmselect"], envPrefixes: ["VICTORIA_METRICS","VICTORIAMETRICS"], envWeak: [] },
+  { id: "graphite", name: "GRAPHITE", kind: "ts", color: 0xf0e07a,
+    deps: ["graphyte","graphitesend","graphite-udp","io.micrometer:micrometer-registry-graphite","io.dropwizard.metrics:metrics-graphite"],
+    imports: ["graphyte","graphitesend","io.micrometer.graphite","com.codahale.metrics.graphite"], images: ["graphiteapp/graphite-statsd"], envPrefixes: ["GRAPHITE","CARBON"], envWeak: [] },
+  { id: "redis", name: "REDIS", kind: "cache", color: 0xff6b6b,
+    deps: ["ioredis","redis","@redis/client","redis-om","@upstash/redis","redis-py","github.com/redis/go-redis/v9","redis.clients:jedis"],
+    imports: ["ioredis","@redis/client","redis.asyncio","github.com/redis/go-redis","github.com/gomodule/redigo/redis","redis.clients.jedis","io.lettuce.core","org.redisson"], images: ["redis","redis/redis-stack","redis/redis-stack-server","bitnami/redis","redislabs/redismod","eqalpha/keydb"], envPrefixes: ["REDIS","REDIS_HOST","REDIS_URL","REDIS_PASSWORD"], envWeak: [] },
+  { id: "valkey", name: "VALKEY", kind: "cache", color: 0xff8585,
+    deps: ["valkey","iovalkey","valkey-glide","@valkey/valkey-glide","github.com/valkey-io/valkey-go","valkey-py"],
+    imports: ["iovalkey","valkey_glide","github.com/valkey-io/valkey-go"], images: ["valkey/valkey","bitnami/valkey"], envPrefixes: ["VALKEY","VALKEY_HOST","VALKEY_URL"], envWeak: [] },
+  { id: "memcached", name: "MEMCACHED", kind: "cache", color: 0xff5252,
+    deps: ["memjs","pymemcache","pylibmc","github.com/bradfitz/gomemcache","net.spy:spymemcached","com.googlecode.xmemcached:xmemcached","aiomcache","memcached","memcache"],
+    imports: ["memjs","pymemcache","pylibmc","github.com/bradfitz/gomemcache/memcache","net.spy.memcached","net.rubyeye.xmemcached"], images: ["memcached","bitnami/memcached"], envPrefixes: ["MEMCACHED","MEMCACHE","MEMCACHED_HOST","MEMCACHED_SERVERS"], envWeak: [] },
+  { id: "hazelcast", name: "HAZELCAST", kind: "cache", color: 0xff9494,
+    deps: ["com.hazelcast:hazelcast","com.hazelcast:hazelcast-spring","com.hazelcast:hazelcast-client"],
+    imports: ["com.hazelcast."], images: ["hazelcast/hazelcast","hazelcast/management-center"], envPrefixes: ["HAZELCAST"], envWeak: [] },
+  { id: "kafka", name: "KAFKA", kind: "queue", color: 0xff7ad9,
+    deps: ["kafkajs","node-rdkafka","@confluentinc/kafka-javascript","confluent-kafka","aiokafka","github.com/segmentio/kafka-go","org.apache.kafka:kafka-clients","github.com/twmb/franz-go"],
+    imports: ["kafkajs","node-rdkafka","confluent_kafka","aiokafka","github.com/segmentio/kafka-go","github.com/Shopify/sarama","org.apache.kafka.clients","org.springframework.kafka"], images: ["confluentinc/cp-kafka","confluentinc/cp-server","bitnami/kafka","apache/kafka","wurstmeister/kafka","redpandadata/redpanda","vectorized/redpanda","confluentinc/cp-zookeeper"], envPrefixes: ["KAFKA","KAFKA_BOOTSTRAP_SERVERS","KAFKA_BROKERS","CONFLUENT","REDPANDA","SCHEMA_REGISTRY"], envWeak: [] },
+  { id: "rabbitmq", name: "RABBITMQ", kind: "queue", color: 0xff86dd,
+    deps: ["amqplib","amqp-connection-manager","pika","aio-pika","github.com/rabbitmq/amqp091-go","com.rabbitmq:amqp-client","org.springframework.amqp:spring-rabbit","lapin"],
+    imports: ["amqplib","amqp-connection-manager","pika","aio_pika","github.com/rabbitmq/amqp091-go","com.rabbitmq.client","org.springframework.amqp","lapin"], images: ["rabbitmq","bitnami/rabbitmq","cloudamqp/lavinmq"], envPrefixes: ["RABBITMQ","RABBITMQ_HOST","RABBITMQ_URL","CLOUDAMQP"], envWeak: [] },
+  { id: "nats", name: "NATS", kind: "queue", color: 0xff6fd3,
+    deps: ["nats","nats.ws","nats-py","github.com/nats-io/nats.go","io.nats:jnats","async-nats","node-nats-streaming","@nats-io/jetstream"],
+    imports: ["github.com/nats-io/nats.go","io.nats.client","async_nats","node-nats-streaming","nats","nats.aio","nats.ws"], images: ["nats","synadia/nats-server","bitnami/nats","natsio/nats-box"], envPrefixes: ["NATS","NATS_URL","NATS_HOST","NATS_SERVERS"], envWeak: [] },
+  { id: "mqtt", name: "MQTT", kind: "queue", color: 0xff90e2,
+    deps: ["mqtt","async-mqtt","paho-mqtt","aiomqtt","github.com/eclipse/paho.mqtt.golang","org.eclipse.paho:org.eclipse.paho.client.mqttv3","rumqttc","MQTTnet"],
+    imports: ["async-mqtt","paho.mqtt","aiomqtt","github.com/eclipse/paho.mqtt.golang","org.eclipse.paho","rumqttc","mqtt"], images: ["eclipse-mosquitto","emqx/emqx","hivemq/hivemq-ce","vernemq/vernemq","nanomq/nanomq"], envPrefixes: ["MQTT","MQTT_HOST","MQTT_BROKER","MOSQUITTO","EMQX"], envWeak: [] },
+  { id: "pulsar", name: "PULSAR", kind: "queue", color: 0xff7ace,
+    deps: ["pulsar-client","github.com/apache/pulsar-client-go","org.apache.pulsar:pulsar-client","org.springframework.pulsar:spring-pulsar"],
+    imports: ["pulsar-client","github.com/apache/pulsar-client-go","org.apache.pulsar.client","org.springframework.pulsar","_pulsar"], images: ["apachepulsar/pulsar","apachepulsar/pulsar-all","streamnative/pulsar","bitnami/pulsar"], envPrefixes: ["PULSAR","PULSAR_URL","PULSAR_BROKER","PULSAR_SERVICE_URL"], envWeak: [] },
+  { id: "nsq", name: "NSQ", kind: "queue", color: 0xff64c9,
+    deps: ["github.com/nsqio/go-nsq"],
+    imports: ["github.com/nsqio/go-nsq"], images: ["nsqio/nsq"], envPrefixes: ["NSQ"], envWeak: ["NSQ"] },
+  { id: "activemq", name: "ACTIVEMQ", kind: "queue", color: 0xff9ce6,
+    deps: ["org.apache.activemq:activemq-client","org.apache.activemq:artemis-jms-client","org.springframework.boot:spring-boot-starter-activemq","org.springframework.boot:spring-boot-starter-artemis"],
+    imports: ["org.apache.activemq","org.apache.activemq.artemis"], images: ["apache/activemq-classic","apache/activemq-artemis","rmohr/activemq","vromero/activemq-artemis"], envPrefixes: ["ACTIVEMQ","ARTEMIS"], envWeak: [] },
+  { id: "sqs", name: "SQS", kind: "queue", color: 0xff72d0,
+    deps: ["@aws-sdk/client-sqs","sqs-consumer","sqs-producer","github.com/aws/aws-sdk-go-v2/service/sqs","software.amazon.awssdk:sqs","shoryuken"],
+    imports: ["@aws-sdk/client-sqs","sqs-consumer","sqs-producer","github.com/aws/aws-sdk-go-v2/service/sqs","software.amazon.awssdk.services.sqs","Aws::SQS"], images: ["softwaremill/elasticmq","roribio16/alpine-sqs"], envPrefixes: ["SQS","AWS_SQS","SQS_QUEUE_URL"], envWeak: ["SQS"] },
+  { id: "sns", name: "SNS", kind: "queue", color: 0xff82d9,
+    deps: ["@aws-sdk/client-sns","github.com/aws/aws-sdk-go-v2/service/sns","software.amazon.awssdk:sns","com.amazonaws:aws-java-sdk-sns"],
+    imports: ["@aws-sdk/client-sns","github.com/aws/aws-sdk-go-v2/service/sns","software.amazon.awssdk.services.sns","Amazon.SNS"], images: [], envPrefixes: ["SNS","AWS_SNS"], envWeak: ["SNS"] },
+  { id: "kinesis", name: "KINESIS", kind: "queue", color: 0xff6cce,
+    deps: ["@aws-sdk/client-kinesis","github.com/aws/aws-sdk-go-v2/service/kinesis","software.amazon.awssdk:kinesis","software.amazon.kinesis:amazon-kinesis-client"],
+    imports: ["@aws-sdk/client-kinesis","github.com/aws/aws-sdk-go-v2/service/kinesis","software.amazon.awssdk.services.kinesis","software.amazon.kinesis"], images: [], envPrefixes: ["KINESIS","AWS_KINESIS"], envWeak: [] },
+  { id: "gcp-pubsub", name: "GCP_PUBSUB", kind: "queue", color: 0xff7adf,
+    deps: ["@google-cloud/pubsub","google-cloud-pubsub","cloud.google.com/go/pubsub","com.google.cloud:google-cloud-pubsub"],
+    imports: ["@google-cloud/pubsub","google.cloud.pubsub","cloud.google.com/go/pubsub","com.google.cloud.pubsub"], images: ["messagebird/gcloud-pubsub-emulator"], envPrefixes: ["PUBSUB","PUBSUB_EMULATOR_HOST","GCP_PUBSUB"], envWeak: [] },
+  { id: "azure-servicebus", name: "AZURE_SERVICEBUS", kind: "queue", color: 0xff88e0,
+    deps: ["@azure/service-bus","azure-servicebus","com.azure:azure-messaging-servicebus","github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus"],
+    imports: ["@azure/service-bus","azure.servicebus","com.azure.messaging.servicebus","github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus"], images: [], envPrefixes: ["SERVICEBUS","AZURE_SERVICEBUS","SERVICE_BUS"], envWeak: [] },
+  { id: "s3", name: "S3", kind: "cloud", color: 0xb06bff,
+    deps: ["@aws-sdk/client-s3","@aws-sdk/s3-request-presigner","@aws-sdk/lib-storage","aws-sdk-s3","github.com/aws/aws-sdk-go-v2/service/s3","software.amazon.awssdk:s3","com.amazonaws:aws-java-sdk-s3","s3fs"],
+    imports: ["@aws-sdk/client-s3","github.com/aws/aws-sdk-go-v2/service/s3","github.com/aws/aws-sdk-go/service/s3","software.amazon.awssdk.services.s3","com.amazonaws.services.s3","aws_sdk_s3","rusoto_s3"], images: ["adobe/s3mock","zenko/cloudserver"], envPrefixes: ["S3","AWS_S3","S3_BUCKET","S3_ENDPOINT","AWS_S3_BUCKET"], envWeak: ["S3"] },
+  { id: "minio", name: "MINIO", kind: "cloud", color: 0xa64fff,
+    deps: ["minio","minio-py","github.com/minio/minio-go","github.com/minio/minio-go/v7","io.minio:minio"],
+    imports: ["minio","github.com/minio/minio-go","io.minio."], images: ["minio/minio","bitnami/minio","minio/mc"], envPrefixes: ["MINIO","MINIO_ENDPOINT","MINIO_ACCESS_KEY","MINIO_SECRET_KEY","MINIO_ROOT_USER","MINIO_BUCKET"], envWeak: [] },
+  { id: "r2", name: "R2", kind: "cloud", color: 0xc08bff,
+    deps: [],
+    imports: [], images: [], envPrefixes: ["R2_BUCKET","R2_ACCESS_KEY_ID","R2_SECRET_ACCESS_KEY","R2_ACCOUNT_ID","CLOUDFLARE_R2"], envWeak: [] },
+  { id: "gcs", name: "GCS", kind: "cloud", color: 0x9b5bff,
+    deps: ["@google-cloud/storage","google-cloud-storage","cloud.google.com/go/storage","com.google.cloud:google-cloud-storage","gcsfs","gcs-resumable-upload"],
+    imports: ["@google-cloud/storage","google.cloud.storage","cloud.google.com/go/storage","com.google.cloud.storage","gcsfs"], images: ["fsouza/fake-gcs-server"], envPrefixes: ["GCS_BUCKET","GOOGLE_CLOUD_STORAGE","GCP_BUCKET"], envWeak: [] },
+  { id: "azure-blob", name: "AZURE_BLOB", kind: "cloud", color: 0xb87bff,
+    deps: ["@azure/storage-blob","azure-storage-blob","github.com/Azure/azure-sdk-for-go/sdk/storage/azblob","com.azure:azure-storage-blob","adlfs"],
+    imports: ["@azure/storage-blob","azure.storage.blob","github.com/Azure/azure-sdk-for-go/sdk/storage/azblob","com.azure.storage.blob"], images: ["mcr.microsoft.com/azure-storage/azurite"], envPrefixes: ["AZURE_STORAGE","AZURE_BLOB","AZURE_STORAGE_CONNECTION_STRING","AZURE_STORAGE_ACCOUNT","AZURE_CONTAINER"], envWeak: [] },
+  { id: "keycloak", name: "KEYCLOAK", kind: "api", color: 0x66e0ff,
+    deps: ["@keycloak/keycloak-admin-client","keycloak-connect","keycloak-js","python-keycloak","github.com/Nerzal/gocloak","org.keycloak:keycloak-admin-client","org.keycloak:keycloak-spring-boot-starter","Keycloak.AuthServices.Authentication"],
+    imports: ["@keycloak/keycloak-admin-client","keycloak-connect","keycloak-js","github.com/Nerzal/gocloak","org.keycloak.","fastapi_keycloak","Keycloak.AuthServices"], images: ["quay.io/keycloak/keycloak","keycloak/keycloak","bitnami/keycloak"], envPrefixes: ["KEYCLOAK","KEYCLOAK_URL","KEYCLOAK_REALM","KEYCLOAK_CLIENT_ID","KEYCLOAK_BASE_URL"], envWeak: [] },
+  { id: "auth0", name: "AUTH0", kind: "api", color: 0x5cd9ff,
+    deps: ["auth0","@auth0/auth0-spa-js","@auth0/auth0-react","@auth0/nextjs-auth0","auth0-python","github.com/auth0/go-auth0","com.auth0:auth0","auth0/auth0-php"],
+    imports: ["@auth0/auth0-spa-js","@auth0/auth0-react","@auth0/nextjs-auth0","github.com/auth0/go-auth0","com.auth0.","Auth0\\SDK","auth0"], images: [], envPrefixes: ["AUTH0","AUTH0_DOMAIN","AUTH0_CLIENT_ID","AUTH0_CLIENT_SECRET","AUTH0_AUDIENCE"], envWeak: [] },
+  { id: "okta", name: "OKTA", kind: "api", color: 0x7ae6ff,
+    deps: ["@okta/okta-sdk-nodejs","@okta/okta-auth-js","@okta/okta-react","github.com/okta/okta-sdk-golang","com.okta.sdk:okta-sdk-api","okta-jwt-verifier","Okta.Sdk","okta/sdk"],
+    imports: ["@okta/okta-sdk-nodejs","@okta/okta-auth-js","github.com/okta/okta-sdk-golang","com.okta.","Okta.Sdk","okta_jwt_verifier"], images: [], envPrefixes: ["OKTA","OKTA_DOMAIN","OKTA_CLIENT_ID","OKTA_ISSUER","OKTA_ORG_URL"], envWeak: [] },
+  { id: "cognito", name: "COGNITO", kind: "api", color: 0x66d4ff,
+    deps: ["@aws-sdk/client-cognito-identity-provider","amazon-cognito-identity-js","pycognito","github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider","software.amazon.awssdk:cognitoidentityprovider","AWSSDK.CognitoIdentityProvider"],
+    imports: ["@aws-sdk/client-cognito-identity-provider","amazon-cognito-identity-js","pycognito","github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider","software.amazon.awssdk.services.cognitoidentityprovider","aws_sdk_cognitoidentityprovider"], images: [], envPrefixes: ["COGNITO","COGNITO_USER_POOL_ID","COGNITO_CLIENT_ID","AWS_COGNITO"], envWeak: [] },
+  { id: "firebase-auth", name: "FIREBASE_AUTH", kind: "api", color: 0x70ddff,
+    deps: ["@firebase/auth","firebase-admin","pyrebase"],
+    imports: ["@firebase/auth","firebase/auth","firebase_admin"], images: [], envPrefixes: ["FIREBASE_AUTH","FIREBASE_PROJECT_ID"], envWeak: [] },
+  { id: "vault", name: "VAULT", kind: "api", color: 0x5ce0ff,
+    deps: ["node-vault","hvac","github.com/hashicorp/vault/api","com.bettercloud:vault-java-driver","vaultrs","hashi-vault-js","VaultSharp","org.springframework.vault:spring-vault-core"],
+    imports: ["node-vault","hvac","github.com/hashicorp/vault/api","io.github.jopenlibs.vault","vaultrs","VaultSharp"], images: ["hashicorp/vault","vault"], envPrefixes: ["VAULT_ADDR","VAULT_TOKEN","VAULT_NAMESPACE","VAULT_ROLE_ID"], envWeak: [] },
+  { id: "oidc-generic", name: "OIDC", kind: "api", color: 0x88ecff,
+    deps: ["openid-client","passport-openidconnect","oidc-client-ts","github.com/coreos/go-oidc","github.com/coreos/go-oidc/v3"],
+    imports: ["openid-client","oidc-client-ts","passport-openidconnect","github.com/coreos/go-oidc"], images: [], envPrefixes: ["OIDC_ISSUER","OIDC_CLIENT_ID"], envWeak: [] },
+];

package/src/infra/infra.detect.js

@@ -0,0 +1,119 @@
+// Signature detection + cached public API for infrastructure detection. Split out of infra.js
+// (which remains the public facade); see that file's header for the pipeline overview and the
+// registry/matching contract documented next to the INFRA_SERVICES re-export.
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+// Concrete infra-item extraction + the shared leaf helpers (lc / safeRead / size caps) live in infra-items.js.
+import { collectInfraItems, itemMetaFor, safeRead, lc, IMPORT_SCAN_MAX_FILES, MAX_FILE_BYTES } from "./infra-items.js";
+import { INFRA_SERVICES } from "./infra-registry.js";
+import { depMatches, imageMatches, envMatches } from "./infra.match.js";
+import { scanRepo } from "./infra.scan.js";
+
+// ---- detection ----------------------------------------------------------------------------------
+export function detectInfraFromScan(scan, registry = INFRA_SERVICES) {
+  const found = new Map(); // id → { service, signals:Set, sources:Set, importTokens:[] }
+  const note = (svc, signal, source) => {
+    let e = found.get(svc.id);
+    if (!e) found.set(svc.id, (e = { service: svc, signals: new Set(), sources: new Set(), importTokens: [] }));
+    if (signal) e.signals.add(signal);
+    if (source) e.sources.add(source);
+  };
+
+  for (const svc of registry) {
+    // 1) manifest deps (highest confidence)
+    for (const tok of svc.deps || []) {
+      for (const d of scan.deps) { if (depMatches(d, tok)) { note(svc, `dep:${d}`, "manifest"); break; } }
+    }
+    // 2) container images
+    for (const tok of svc.images || []) {
+      for (const im of scan.imageSegs) { if (imageMatches(im.segs, tok)) { note(svc, `image:${im.raw}`, "image"); break; } }
+    }
+    // 3) env-var name conventions
+    const weakSet = new Set((svc.envWeak || []).map((s) => s.toUpperCase()));
+    for (const tok of svc.envPrefixes || []) {
+      for (const k of scan.envKeys) { if (envMatches(k, tok, weakSet.has(tok.toUpperCase()))) { note(svc, `env:${k}`, "env"); break; } }
+    }
+  }
+
+  // 4) source imports → attribute connector files (and a weak detection signal). Only scan if any
+  // service has import tokens; pre-filter files by a combined token regex (cheap), like apimap.
+  const importIndex = []; // { svc, token }
+  for (const svc of registry) for (const tok of svc.imports || []) importIndex.push({ svc, tok: lc(tok) });
+  const filesByService = new Map(); // id → Set(relPath)
+  if (importIndex.length && scan.codeFiles.length) {
+    const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pre = new RegExp(importIndex.map((x) => esc(x.tok)).join("|"), "i");
+    // Reading every source file is the only O(repo-size) cost here and it runs synchronously, so cap it:
+    // connector-file attribution is best-effort and detection from manifests/images/env is already complete
+    // above. ~5k files keeps the cold scan well under a second even on a large monorepo (then it's cached).
+    const scanFiles = scan.codeFiles.length > IMPORT_SCAN_MAX_FILES ? scan.codeFiles.slice(0, IMPORT_SCAN_MAX_FILES) : scan.codeFiles;
+    for (const f of scanFiles) {
+      const text = safeRead(f.full);
+      if (!text || text.length > MAX_FILE_BYTES || !pre.test(text)) continue;
+      const lcText = text.toLowerCase();
+      for (const { svc, tok } of importIndex) {
+        // require a quoted/pathish occurrence so a stray word doesn't match: 'tok' "tok" `tok` tok/ tok"
+        if (lcText.includes(`"${tok}`) || lcText.includes(`'${tok}`) || lcText.includes("`" + tok) || lcText.includes(`/${tok}"`) || lcText.includes(tok + "/")) {
+          let set = filesByService.get(svc.id);
+          if (!set) filesByService.set(svc.id, (set = new Set()));
+          set.add(f.path);
+          // imports alone also count as a (weaker) detection signal
+          if (!found.has(svc.id)) note(svc, `import:${tok}`, "import");
+          else found.get(svc.id).sources.add("import");
+        }
+      }
+    }
+  }
+
+  const entries = [...found.values()];
+  const itemsByService = collectInfraItems(scan, entries, filesByService);
+  const services = entries.map(({ service, signals, sources }) => {
+    const files = [...(filesByService.get(service.id) || [])].sort().slice(0, 40);
+    const itemData = itemsByService.get(service.id) || { ...itemMetaFor(service), items: [] };
+    // confidence: a parsed manifest dep or image is hard evidence; env/import alone is softer.
+    const hard = sources.has("manifest") || sources.has("image");
+    const confidence = hard ? "high" : sources.has("env") && sources.has("import") ? "high" : sources.has("env") || sources.has("import") ? "medium" : "low";
+    return {
+      id: service.id, name: service.name, kind: service.kind, color: service.color,
+      confidence, sources: [...sources].sort(), signals: [...signals].sort().slice(0, 24), files,
+      items: itemData.items || [], itemLabel: itemData.itemLabel || itemData.label, unit: itemData.unit || "",
+    };
+  });
+  // stable, useful order: hard evidence first, then by source count, then name
+  const rank = (c) => (c === "high" ? 0 : c === "medium" ? 1 : 2);
+  services.sort((a, b) => rank(a.confidence) - rank(b.confidence) || b.signals.length - a.signals.length || a.name.localeCompare(b.name));
+  return services;
+}
+
+// ---- public API (cached by manifest/compose/env mtime) ------------------------------------------
+const _cache = new Map(); // repoPath → { sig, result }
+
+// cheap cache signature: newest mtime among the files that drive detection. If none change, reuse.
+function repoSignature(repoPath) {
+  let newest = 0, seen = 0;
+  const probe = (p) => { try { const st = statSync(p); if (st.isFile()) { newest = Math.max(newest, st.mtimeMs); seen++; } } catch { /* missing — skip */ } };
+  const roots = ["package.json", "go.mod", "go.sum", "requirements.txt", "pyproject.toml", "Pipfile", "Cargo.toml", "pom.xml", "build.gradle", "build.gradle.kts", "composer.json", "Gemfile", ".env", "docker-compose.yml", "docker-compose.yaml", "compose.yml", "Dockerfile", "skaffold.yaml"];
+  for (const r of roots) probe(join(repoPath, r));
+  for (const dir of ["k8s", "kubernetes", "deploy", "manifests", "helm", "charts", ".github"]) {
+    try { for (const e of readdirSync(join(repoPath, dir), { withFileTypes: true })) if (e.isFile()) probe(join(repoPath, dir, e.name)); } catch { /* no such dir */ }
+  }
+  return `${seen}:${Math.round(newest)}`;
+}
+
+// Detect the backing services a repo talks to. Cheap & cached; safe to call from repos:graph-analysis.
+export function detectInfra(repoPath, opts = {}) {
+  if (!repoPath || !existsSync(repoPath)) return { ok: false, error: "Repo path not found", services: [] };
+  const sig = repoSignature(repoPath);
+  const cached = _cache.get(repoPath);
+  if (!opts.force && cached && cached.sig === sig) return cached.result;
+  let result;
+  try {
+    const scan = scanRepo(repoPath);
+    const services = detectInfraFromScan(scan);
+    result = { ok: true, services, scanned: { manifests: scan.manifests, codeFiles: scan.codeFiles.length, envKeys: scan.envKeys.size, images: scan.imageSegs.length } };
+  } catch (error) {
+    result = { ok: false, error: error.message, services: [] };
+  }
+  _cache.set(repoPath, { sig, result });
+  return result;
+}