weavatrix 0.3.14 → 1.0.0

package/src/graph/repo-registry.js

@@ -1,124 +0,0 @@
-// Global local registry for repository graphs. Absolute paths never leave the machine; composing
-// extensions may use the opaque UUID. Identity is anchored in each canonical graph folder so simultaneous MCP
-// processes cannot mint different IDs for the same repository.
-import {randomUUID} from 'node:crypto'
-import {existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync} from 'node:fs'
-import {basename, join, relative, resolve} from 'node:path'
-import process from 'node:process'
-import {graphStorageKey} from './layout.js'
-import {atomicWriteFileSync, withFileLockSync} from './file-lock.js'
-
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-const MARKER = '.repository-id'
-
-const normalized = (value) => {
-    const path = String(value || '').replace(/\\/g, '/').replace(/\/+$/, '')
-    return process.platform === 'win32' ? path.toLowerCase() : path
-}
-
-const realOrResolved = (value) => {
-    try { return realpathSync.native(value) } catch { return resolve(value) }
-}
-
-const canonicalGraphDir = (repoPath, graphHome) => join(resolve(graphHome), graphStorageKey(repoPath))
-const markerPath = (graphDir) => join(graphDir, MARKER)
-
-export function registryPath(graphHome) { return join(graphHome, 'repositories.json') }
-
-export function readRepositoryRegistry(graphHome) {
-    try {
-        const parsed = JSON.parse(readFileSync(registryPath(graphHome), 'utf8'))
-        return parsed?.repositoryRegistryV === 1 && Array.isArray(parsed.repositories)
-            ? parsed.repositories.filter((item) => item && typeof item === 'object')
-            : []
-    } catch { return [] }
-}
-
-function writeRegistry(graphHome, repositories) {
-    atomicWriteFileSync(registryPath(graphHome), JSON.stringify({repositoryRegistryV: 1, repositories}, null, 2), 'utf8')
-}
-
-function readMarker(graphDir) {
-    try {
-        const id = readFileSync(markerPath(graphDir), 'utf8').trim()
-        return UUID.test(id) ? id : null
-    } catch { return null }
-}
-
-function createOrReadMarker(graphDir, preferredId) {
-    mkdirSync(graphDir, {recursive: true})
-    const path = markerPath(graphDir)
-    const existing = readMarker(graphDir)
-    if (existing) return existing
-    if (existsSync(path)) throw new Error(`invalid repository identity marker: ${path}`)
-    const candidate = UUID.test(String(preferredId || '')) ? preferredId : randomUUID()
-    try { writeFileSync(path, `${candidate}\n`, {encoding: 'utf8', flag: 'wx'}) }
-    catch (error) {
-        if (error?.code !== 'EEXIST') throw error
-        const raced = readMarker(graphDir)
-        if (!raced) throw new Error(`invalid repository identity marker after concurrent registration: ${path}`)
-        return raced
-    }
-    return candidate
-}
-
-export function registerRepository({repoPath, graphDir, graphHome}) {
-    mkdirSync(graphHome, {recursive: true})
-    const real = realOrResolved(repoPath)
-    const canonical = canonicalGraphDir(real, graphHome)
-    if (normalized(realOrResolved(graphDir)) !== normalized(realOrResolved(canonical))) {
-        throw new Error(`repository graphs must be registered from the canonical graph directory: ${canonical}`)
-    }
-    return withFileLockSync(join(graphHome, '.repositories.lock'), () => {
-        const key = normalized(real)
-        const repositories = readRepositoryRegistry(graphHome)
-        let record = repositories.find((item) => normalized(item.repoPath) === key)
-        const now = new Date().toISOString()
-        const repositoryId = createOrReadMarker(canonical, record?.repositoryId)
-        if (!record) {
-            record = {repositoryId, repoPath: real, label: basename(real) || 'repo', graphDir: canonical, firstSeenAt: now, lastSeenAt: now}
-            repositories.push(record)
-        } else {
-            record.repositoryId = repositoryId
-            record.repoPath = real
-            record.graphDir = canonical
-            record.label = basename(real) || record.label || 'repo'
-            record.lastSeenAt = now
-        }
-        const deduped = repositories.filter((item, index, all) =>
-            normalized(item.repoPath) !== key || all.findIndex((candidate) => normalized(candidate.repoPath) === key) === index)
-        deduped.sort((a, b) => String(a.label).localeCompare(String(b.label)) || String(a.repositoryId).localeCompare(String(b.repositoryId)))
-        writeRegistry(graphHome, deduped)
-        return {...record}
-    })
-}
-
-export function repositoryRecord(repoPath, graphHome) {
-    const real = realOrResolved(repoPath)
-    const key = normalized(real)
-    return liveRepositoryRecords(graphHome).find((item) => normalized(item.repoPath) === key) || null
-}
-
-function validLiveRecord(item, graphHome) {
-    if (!UUID.test(String(item?.repositoryId || '')) || typeof item?.repoPath !== 'string' || typeof item?.graphDir !== 'string') return null
-    let repoReal
-    let graphHomeReal
-    let graphReal
-    try {
-        repoReal = realpathSync.native(item.repoPath)
-        graphHomeReal = realpathSync.native(graphHome)
-        graphReal = realpathSync.native(item.graphDir)
-        if (!statSync(repoReal).isDirectory() || !existsSync(join(repoReal, '.git'))) return null
-        if (!statSync(graphReal).isDirectory() || !statSync(join(graphReal, 'graph.json')).isFile()) return null
-    } catch { return null }
-    if (normalized(graphReal) !== normalized(realOrResolved(canonicalGraphDir(repoReal, graphHomeReal)))) return null
-    const rel = relative(graphHomeReal, graphReal)
-    if (!rel || rel.startsWith('..') || resolve(graphHomeReal, rel) !== resolve(graphReal)) return null
-    if (readMarker(graphReal) !== item.repositoryId) return null
-    return {...item, repoPath: repoReal, graphDir: graphReal}
-}
-
-export function liveRepositoryRecords(graphHome) {
-    if (!existsSync(graphHome)) return []
-    return readRepositoryRegistry(graphHome).map((item) => validLiveRecord(item, graphHome)).filter(Boolean)
-}

package/src/graph/resolvers/rust.js

@@ -1,117 +0,0 @@
-import {join} from 'node:path'
-
-const cleanRustRel = (path) => String(path || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+/g, '/').replace(/\/$/, '').replace(/^\.$/, '')
-const rustDir = (path) => {
-  const clean = cleanRustRel(path)
-  const index = clean.lastIndexOf('/')
-  return index < 0 ? '' : clean.slice(0, index)
-}
-const rustBase = (path) => {
-  const clean = cleanRustRel(path)
-  const index = clean.lastIndexOf('/')
-  return index < 0 ? clean : clean.slice(index + 1)
-}
-const rustJoin = (...parts) => cleanRustRel(join(...parts.filter((part) => part != null && part !== '')))
-
-export function createRustResolvers(fileSet) {
-  const rustFiles = new Set([...fileSet].filter((file) => file.endsWith('.rs')))
-  const rustRoots = new Map()
-  for (const file of rustFiles) {
-    const base = rustBase(file)
-    if (base !== 'lib.rs' && base !== 'main.rs') continue
-    const dir = rustDir(file)
-    let root = rustRoots.get(dir)
-    if (!root) rustRoots.set(dir, (root = {base: dir, lib: null, main: null}))
-    root[base === 'lib.rs' ? 'lib' : 'main'] = file
-  }
-  const rustRootList = [...rustRoots.values()].sort((a, b) => b.base.length - a.base.length)
-
-  const rustContext = (fromRel) => {
-    const clean = cleanRustRel(fromRel)
-    const base = rustBase(clean)
-    const dir = rustDir(clean)
-    if (base === 'lib.rs' || base === 'main.rs') return {base: dir, rootFile: clean}
-    if (/^(?:bin|examples|tests|benches)$/.test(rustBase(dir))) return {base: dir, rootFile: clean}
-    for (const root of rustRootList) {
-      if (!root.base || clean.startsWith(root.base + '/')) return {base: root.base, rootFile: root.lib || root.main}
-    }
-    return {base: dir, rootFile: clean}
-  }
-  const rustModuleBase = (fromRel) => {
-    const context = rustContext(fromRel)
-    if (context.rootFile === cleanRustRel(fromRel)) return rustDir(fromRel)
-    const name = rustBase(fromRel)
-    if (name === 'lib.rs' || name === 'main.rs' || name === 'mod.rs') return rustDir(fromRel)
-    return rustJoin(rustDir(fromRel), name.replace(/\.rs$/, ''))
-  }
-  const rustInlineBase = (fromRel, inlineModules = []) => {
-    let base = rustModuleBase(fromRel)
-    for (let index = 0; index < inlineModules.length; index++) {
-      const module = inlineModules[index] || {}
-      if (module.path) {
-        const parent = index === 0 ? rustDir(fromRel) : base
-        base = rustJoin(parent, module.path)
-      } else base = rustJoin(base, module.name)
-    }
-    return base
-  }
-  const rustModuleFile = (moduleBase, context) => {
-    const clean = cleanRustRel(moduleBase)
-    if (clean === cleanRustRel(context.base) && context.rootFile && rustFiles.has(context.rootFile)) return context.rootFile
-    const flat = clean + '.rs'
-    if (rustFiles.has(flat)) return flat
-    const legacy = rustJoin(clean, 'mod.rs')
-    return rustFiles.has(legacy) ? legacy : null
-  }
-
-  const resolveRustMod = (fromRel, name, {inlineModules = [], explicitPath = ''} = {}) => {
-    const clean = cleanRustRel(fromRel)
-    if (explicitPath) {
-      const parent = inlineModules.length ? rustInlineBase(clean, inlineModules) : rustDir(clean)
-      const target = rustJoin(parent, explicitPath)
-      return rustFiles.has(target) ? target : null
-    }
-    const targetBase = rustJoin(rustInlineBase(clean, inlineModules), String(name || '').replace(/^r#/, ''))
-    return rustModuleFile(targetBase, rustContext(clean))
-  }
-
-  const resolveRustPath = (fromRel, rawSegments, {inlineModules = [], unqualified = true} = {}) => {
-    const clean = cleanRustRel(fromRel)
-    const segments = (Array.isArray(rawSegments) ? rawSegments : String(rawSegments || '').split('::'))
-      .map((segment) => String(segment).trim().replace(/^r#/, '')).filter(Boolean)
-    if (!segments.length) return null
-    const context = rustContext(clean)
-    const current = rustInlineBase(clean, inlineModules)
-    const rest = [...segments]
-    const starts = []
-    let anchored = false
-    if (rest[0] === 'crate') { anchored = true; rest.shift(); starts.push(context.base) }
-    else if (rest[0] === 'self') { anchored = true; rest.shift(); starts.push(current) }
-    else if (rest[0] === 'super') {
-      anchored = true
-      let base = current
-      while (rest[0] === 'super') { rest.shift(); base = rustDir(base) }
-      if (context.base && base !== context.base && !base.startsWith(context.base + '/')) return null
-      starts.push(base)
-    } else if (unqualified) {
-      starts.push(context.base)
-      if (current !== context.base) starts.push(current)
-    } else return null
-
-    for (const start of starts) {
-      const minimum = anchored ? 0 : 1
-      for (let used = rest.length; used >= minimum; used--) {
-        const target = rustModuleFile(rustJoin(start, ...rest.slice(0, used)), context)
-        if (target) return {
-          targetFile: target,
-          consumed: segments.length - rest.length + used,
-          remaining: rest.slice(used),
-          anchored,
-        }
-      }
-    }
-    return null
-  }
-
-  return {resolveRustMod, resolveRustPath}
-}

package/src/infra/infra-items.js

@@ -1,255 +0,0 @@
-// 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 };