flowseeker 0.1.7

package/dist/index/workspaceIndex.js

@@ -0,0 +1,518 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOrBuildWorkspaceIndex = loadOrBuildWorkspaceIndex;
+exports.selectIndexCandidates = selectIndexCandidates;
+exports.clearNodeWorkspaceIndex = clearNodeWorkspaceIndex;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const dependencyExtractor_1 = require("./dependencyExtractor");
+const fileDiscovery_1 = require("./fileDiscovery");
+const structuredExtractor_1 = require("./structuredExtractor");
+const text_1 = require("../utils/text");
+const fileScanner_1 = require("../pipeline/fileScanner");
+const subsystem_1 = require("../pipeline/subsystem");
+const indexVersion = 6;
+const tokenLimitPerFile = 2500;
+async function loadOrBuildWorkspaceIndex(rootPath, config, options = {}) {
+    const startedAt = options.startedAt ?? Date.now();
+    const resolvedRoot = path.resolve(rootPath);
+    const discovery = await (0, fileDiscovery_1.discoverWorkspaceFiles)(resolvedRoot, config, { startedAt, shouldCancel: options.shouldCancel });
+    const priorIndex = await readIndex(resolvedRoot);
+    const currentFingerprint = fingerprintConfig(config);
+    const reusablePriorIndex = priorIndex?.configFingerprint === currentFingerprint ? priorIndex : undefined;
+    const priorByPath = new Map((reusablePriorIndex?.files ?? []).map((file) => [file.relativePath, file]));
+    const files = [];
+    let reusedFiles = 0;
+    let updatedFiles = 0;
+    let updatedBytes = 0;
+    const maxUpdatedBytes = config.pipeline.maxTotalBytesMb * 1024 * 1024;
+    let stopReason = discovery.stopReason;
+    let processedFiles = 0;
+    for (const discovered of discovery.files) {
+        processedFiles += 1;
+        if (options.shouldCancel?.()) {
+            stopReason = "cancelled";
+            break;
+        }
+        if (Date.now() - startedAt > config.pipeline.maxScanMs) {
+            stopReason = `maxScanMs ${config.pipeline.maxScanMs} reached while indexing`;
+            break;
+        }
+        if (updatedBytes >= maxUpdatedBytes) {
+            stopReason = `maxTotalBytesMb ${config.pipeline.maxTotalBytesMb} reached while indexing`;
+            break;
+        }
+        if (processedFiles === 1 || processedFiles % 25 === 0) {
+            options.onProgress?.(`Indexing ${processedFiles}/${discovery.files.length}: ${formatProgressPath(discovered.relativePath)}`);
+        }
+        const indexed = await indexFile(discovered, priorByPath.get(discovered.relativePath), config);
+        if (!indexed) {
+            continue;
+        }
+        if (indexed.reused) {
+            reusedFiles += 1;
+        }
+        else {
+            updatedFiles += 1;
+            updatedBytes += indexed.file.size;
+        }
+        files.push(indexed.file);
+        if ((reusedFiles + updatedFiles) % 50 === 0) {
+            options.onProgress?.(`Indexed ${reusedFiles + updatedFiles}/${discovery.files.length} files`);
+        }
+        if (processedFiles % 25 === 0) {
+            await yieldToHost();
+        }
+    }
+    const index = {
+        version: indexVersion,
+        rootPath: resolvedRoot,
+        createdAt: new Date().toISOString(),
+        configFingerprint: currentFingerprint,
+        files
+    };
+    await writeIndex(resolvedRoot, index);
+    return {
+        index,
+        discoveredFiles: discovery.files.length,
+        reusedFiles,
+        updatedFiles,
+        indexedBytes: files.reduce((sum, file) => sum + file.size, 0),
+        indexedTokens: files.reduce((sum, file) => sum + (file.tokenCount ?? Math.ceil(file.size / 4)), 0),
+        stopReason
+    };
+}
+function selectIndexCandidates(index, profile, config) {
+    const terms = (0, fileScanner_1.getWeightedTerms)(profile);
+    if (terms.length === 0) {
+        return [];
+    }
+    const scored = index.files
+        .map((file) => ({
+        file,
+        score: scoreIndexedFile(file, terms, profile)
+    }))
+        .filter((item) => item.score > 0)
+        .sort((left, right) => right.score - left.score);
+    const selected = new Map();
+    const maxCandidates = config.index.maxIndexedCandidateFiles;
+    const maxSeeds = Math.min(config.index.maxSeedCandidateFiles, maxCandidates);
+    const seeds = scored.slice(0, maxSeeds).map((item) => item.file);
+    for (const seed of seeds) {
+        selected.set(seed.relativePath, seed);
+    }
+    if (config.index.enableDependencyExpansion && selected.size < maxCandidates) {
+        const maxExpansion = Math.min(config.index.maxDependencyExpansionFiles, maxCandidates - selected.size);
+        let expanded = 0;
+        for (const related of findDependencyRelatedFiles(index.files, seeds, maxExpansion)) {
+            if (expanded >= maxExpansion || selected.size >= maxCandidates) {
+                break;
+            }
+            if (!selected.has(related.relativePath)) {
+                selected.set(related.relativePath, related);
+                expanded += 1;
+            }
+        }
+    }
+    for (const item of scored) {
+        if (selected.size >= maxCandidates) {
+            break;
+        }
+        selected.set(item.file.relativePath, item.file);
+    }
+    return Array.from(selected.values()).map((item) => ({
+        absolutePath: path.join(index.rootPath, item.relativePath),
+        relativePath: item.relativePath
+    }));
+}
+function findDependencyRelatedFiles(files, seeds, maxResults) {
+    const lookup = buildDependencyLookup(files);
+    const related = [];
+    for (const seed of seeds) {
+        if (related.length >= maxResults) {
+            break;
+        }
+        for (const candidate of lookupImportTargets(seed, lookup)) {
+            if (candidate.relativePath !== seed.relativePath && importsFile(seed, candidate)) {
+                related.push(candidate);
+            }
+            if (related.length >= maxResults) {
+                break;
+            }
+        }
+        if (related.length >= maxResults) {
+            break;
+        }
+        for (const candidate of lookupImporters(seed, lookup)) {
+            if (candidate.relativePath !== seed.relativePath && importsFile(candidate, seed)) {
+                related.push(candidate);
+            }
+            if (related.length >= maxResults) {
+                break;
+            }
+        }
+        if (related.length >= maxResults) {
+            break;
+        }
+        for (const candidate of lookupCallGraphRelated(seed, lookup)) {
+            if (candidate.relativePath !== seed.relativePath) {
+                related.push(candidate);
+            }
+            if (related.length >= maxResults) {
+                break;
+            }
+        }
+    }
+    return uniqueByPath(related);
+}
+function buildDependencyLookup(files) {
+    const byBaseName = new Map();
+    const byImportBaseName = new Map();
+    const bySymbolName = new Map();
+    const byCallName = new Map();
+    for (const file of files) {
+        addToMap(byBaseName, fileBaseName(file.relativePath), file);
+        for (const importSource of file.imports) {
+            addToMap(byImportBaseName, importBaseName(importSource), file);
+        }
+        for (const symbol of file.symbols) {
+            addToMap(bySymbolName, normalizeGraphName(symbol.name), file);
+        }
+        for (const call of file.calls ?? []) {
+            addToMap(byCallName, normalizeGraphName(call), file);
+        }
+    }
+    return { byBaseName, byImportBaseName, bySymbolName, byCallName };
+}
+function lookupImportTargets(seed, lookup) {
+    const candidates = [];
+    for (const importSource of seed.imports) {
+        candidates.push(...(lookup.byBaseName.get(importBaseName(importSource)) ?? []));
+    }
+    return uniqueByPath(candidates);
+}
+function lookupImporters(seed, lookup) {
+    return lookup.byImportBaseName.get(fileBaseName(seed.relativePath)) ?? [];
+}
+function lookupCallGraphRelated(seed, lookup) {
+    const candidates = [];
+    for (const call of seed.calls ?? []) {
+        candidates.push(...(lookup.bySymbolName.get(normalizeGraphName(call)) ?? []));
+    }
+    for (const symbol of seed.symbols) {
+        candidates.push(...(lookup.byCallName.get(normalizeGraphName(symbol.name)) ?? []));
+    }
+    return uniqueByPath(candidates);
+}
+function normalizeGraphName(name) {
+    const parts = name.split(/\.|::|->/).filter(Boolean);
+    return (0, text_1.normalizeText)(parts[parts.length - 1] ?? name);
+}
+function addToMap(map, key, file) {
+    if (!key) {
+        return;
+    }
+    const files = map.get(key) ?? [];
+    files.push(file);
+    map.set(key, files);
+}
+function fileBaseName(relativePath) {
+    return path.posix.basename(relativePath.replace(/\\/g, "/").replace(/\.[^.]+$/, "")).toLowerCase();
+}
+function importBaseName(importSource) {
+    return path.posix.basename(importSource.replace(/\\/g, "/").replace(/\.[^.]+$/, "")).toLowerCase();
+}
+function importsFile(source, target) {
+    return source.imports.some((importSource) => (0, dependencyExtractor_1.fileMatchesImport)(target.relativePath, importSource));
+}
+function uniqueByPath(files) {
+    const seen = new Set();
+    const result = [];
+    for (const file of files) {
+        if (!seen.has(file.relativePath)) {
+            seen.add(file.relativePath);
+            result.push(file);
+        }
+    }
+    return result;
+}
+async function clearNodeWorkspaceIndex(rootPath) {
+    try {
+        await fs.rm(cachePath(rootPath), { force: true });
+    }
+    catch {
+        // Cache may not exist.
+    }
+}
+async function indexFile(discovered, prior, config) {
+    if (!(0, text_1.isLikelyTextPath)(discovered.relativePath)) {
+        return undefined;
+    }
+    let stat;
+    try {
+        stat = await fs.stat(discovered.absolutePath);
+    }
+    catch {
+        return undefined;
+    }
+    if (stat.size > config.project.maxFileSizeKb * 1024) {
+        return undefined;
+    }
+    if (prior && prior.size === stat.size && prior.mtimeMs === stat.mtimeMs) {
+        return { file: prior, reused: true };
+    }
+    let content;
+    try {
+        content = await fs.readFile(discovered.absolutePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    if (content.includes("\u0000")) {
+        return undefined;
+    }
+    const structuredNodes = extractStructuredNodesForIndex(discovered.relativePath, content);
+    const symbols = extractSymbols(structuredNodes);
+    const calls = extractCalls(structuredNodes);
+    const subsystemTerms = (0, subsystem_1.inferSubsystemTerms)(discovered.relativePath, symbols.map((symbol) => symbol.name));
+    return {
+        reused: false,
+        file: {
+            relativePath: discovered.relativePath,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            language: (0, text_1.languageFromPath)(discovered.relativePath),
+            tokenCount: (0, text_1.fastTokenEstimate)(`${discovered.relativePath}\n${content}`),
+            tokens: tokenizeForIndex(`${discovered.relativePath}\n${content}\n${symbolText(symbols)}`),
+            imports: (0, dependencyExtractor_1.extractImports)(content).map((item) => item.source).slice(0, 50),
+            symbols,
+            calls,
+            subsystem: subsystemTerms[0],
+            subsystemTerms
+        }
+    };
+}
+function scoreIndexedFile(file, terms, profile) {
+    const normalizedPath = (0, text_1.normalizeText)(file.relativePath);
+    const compactPath = normalizedPath.replace(/[^a-z0-9]+/g, "");
+    const normalizedBaseName = (0, text_1.normalizeText)(fileBaseName(file.relativePath));
+    const compactBaseName = normalizedBaseName.replace(/[^a-z0-9]+/g, "");
+    const tokenSet = new Set(file.tokens);
+    const imports = file.imports.map(text_1.normalizeText).join("\n");
+    const symbolNames = file.symbols.map((symbol) => (0, text_1.normalizeText)(symbol.name));
+    const callNames = (file.calls ?? []).map(text_1.normalizeText);
+    const subsystemTerms = file.subsystemTerms ?? [];
+    const taskSubsystems = (0, subsystem_1.inferTaskSubsystemTerms)(profile);
+    let score = 0;
+    for (const term of terms) {
+        const normalizedTerm = (0, text_1.normalizeText)(term.term);
+        const compactTerm = normalizedTerm.replace(/[^a-z0-9]+/g, "");
+        if (normalizedPath.includes(normalizedTerm)) {
+            score += 6 * term.weight;
+        }
+        if (compactTerm.length >= 5 && compactBaseName.includes(compactTerm)) {
+            score += 18 * term.weight;
+        }
+        if (compactTerm.length >= 5 && compactPath.includes(compactTerm)) {
+            score += 8 * term.weight;
+        }
+        if (tokenSet.has(normalizedTerm)) {
+            score += 5 * term.weight;
+        }
+        if (imports.includes(normalizedTerm)) {
+            score += 2 * term.weight;
+        }
+        if (symbolNames.some((symbol) => symbol === normalizedTerm || symbol.includes(normalizedTerm))) {
+            score += 5 * term.weight;
+        }
+        if (callNames.some((call) => call === normalizedTerm || call.includes(normalizedTerm))) {
+            score += 3 * term.weight;
+        }
+        if (subsystemTerms.some((subsystem) => subsystem === normalizedTerm || subsystem.includes(normalizedTerm))) {
+            score += 4 * term.weight;
+        }
+    }
+    const subsystemMatches = subsystemTerms.filter((subsystem) => taskSubsystems.some((taskSubsystem) => subsystem === taskSubsystem || subsystem.includes(taskSubsystem) || taskSubsystem.includes(subsystem)));
+    if (subsystemMatches.length > 0) {
+        score += 4 + Math.min(10, subsystemMatches.length * 4);
+    }
+    if (wantsSourceCode(profile) && /(^|\/)src\//.test(file.relativePath.replace(/\\/g, "/"))) {
+        score += 14;
+    }
+    if (score <= 0) {
+        return 0;
+    }
+    return Math.max(0, score + pathQualityModifier(file.relativePath));
+}
+function wantsSourceCode(profile) {
+    return /\b(source\s+code|source|src|implementation)\b/.test(profile.normalizedTask);
+}
+function pathQualityModifier(relativePath) {
+    const normalizedPath = relativePath.replace(/\\/g, "/").toLowerCase();
+    let modifier = 0;
+    if (/(^|\/)(src|app|lib|server|backend|frontend|packages|modules|routes|database|resources)(\/|$)/.test(normalizedPath)) {
+        modifier += 5;
+    }
+    if (/(controller|handler|service|repository|model|route|router|worker|job|listener|command|resolver|middleware|policy|request|resource)/.test(normalizedPath)) {
+        modifier += 8;
+    }
+    if (/(^|\/)(tests?|specs?|__tests__)(\/|$)|\.(test|spec)\./.test(normalizedPath)) {
+        modifier += 4;
+    }
+    if (/(^|\/)(node_modules|vendor|dist|build|out|coverage|cache|tmp|temp|storage\/framework|target|\.next|\.nuxt|\.svelte-kit)(\/|$)/.test(normalizedPath)) {
+        modifier -= 40;
+    }
+    if (/(^|\/)\.flowseeker(\/|$)|(^|\/)_gen[^/]*\.(py|sh)$|(^|\/)_bulk_write\.js$/.test(normalizedPath)) {
+        modifier -= 80;
+    }
+    if (/(^|\/)(__generated__|generated|gen|codegen|autogen|snapshots?|__snapshots__|fixtures?|mocks?)(\/|$)|\.generated\.|\.(pb\.go|pb\.cc|pb\.h|pb\.rs|pb\.swift)$|_pb2(_grpc)?\.py$|\.snap$/.test(normalizedPath)) {
+        modifier -= 34;
+    }
+    if (/(^|\/)(public|assets?|static|dashboard\/plugins|plugins|themes?)(\/|$)/.test(normalizedPath)) {
+        modifier -= 22;
+    }
+    if (/(\.min\.(js|css)$|\.(bundle|chunk)\.(js|css)$|jquery|bootstrap|datatables|select2|moment|chart(\.|js)|ckeditor|tinymce|sweetalert|slick|swiper)/.test(normalizedPath)) {
+        modifier -= 24;
+    }
+    if (/(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|composer\.lock|poetry\.lock|cargo\.lock)$/.test(normalizedPath)) {
+        modifier -= 40;
+    }
+    return modifier;
+}
+function tokenizeForIndex(text) {
+    const spaced = text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ");
+    const normalized = (0, text_1.normalizeText)(spaced);
+    const tokens = new Set();
+    const pattern = /[a-z0-9]{2,}/g;
+    const orderedTokens = [];
+    let match = pattern.exec(normalized);
+    while (match && tokens.size < tokenLimitPerFile) {
+        tokens.add(match[0]);
+        orderedTokens.push(match[0]);
+        match = pattern.exec(normalized);
+    }
+    for (let index = 0; index < orderedTokens.length - 1 && tokens.size < tokenLimitPerFile; index += 1) {
+        tokens.add(`${orderedTokens[index]}_${orderedTokens[index + 1]}`);
+    }
+    for (let index = 0; index < orderedTokens.length - 2 && tokens.size < tokenLimitPerFile; index += 1) {
+        tokens.add(`${orderedTokens[index]}_${orderedTokens[index + 1]}_${orderedTokens[index + 2]}`);
+    }
+    return Array.from(tokens);
+}
+function extractStructuredNodesForIndex(relativePath, content) {
+    const language = (0, structuredExtractor_1.detectLanguage)(relativePath);
+    if (!language) {
+        return [];
+    }
+    return (0, structuredExtractor_1.extractStructuredNodes)(content.slice(0, 200000), language);
+}
+function extractSymbols(nodes) {
+    return nodes
+        .filter((node) => node.kind === "declaration" && node.name)
+        .slice(0, 80)
+        .map((node) => ({
+        name: node.name ?? "",
+        kind: "declaration",
+        line: node.range.startLine,
+        exported: node.parent === "exported"
+    }));
+}
+function extractCalls(nodes) {
+    const calls = nodes
+        .filter((node) => node.kind === "call" && node.name)
+        .map((node) => normalizeGraphName(node.name ?? ""))
+        .filter((name) => name && !commonCallNames.has(name));
+    return Array.from(new Set(calls)).slice(0, 120);
+}
+const commonCallNames = new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "return",
+    "typeof",
+    "sizeof",
+    "console",
+    "log",
+    "map",
+    "filter",
+    "reduce",
+    "then",
+    "catch",
+    "finally"
+]);
+function symbolText(symbols) {
+    return symbols.map((symbol) => symbol.name).join("\n");
+}
+function formatProgressPath(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/");
+    return normalized.length > 96 ? `...${normalized.slice(-93)}` : normalized;
+}
+function yieldToHost() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function readIndex(rootPath) {
+    try {
+        const text = await fs.readFile(cachePath(rootPath), "utf8");
+        const parsed = JSON.parse(text);
+        if (parsed.version !== indexVersion || parsed.rootPath !== path.resolve(rootPath)) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeIndex(rootPath, index) {
+    const filePath = cachePath(rootPath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(index), "utf8");
+}
+function cachePath(rootPath) {
+    return path.join(path.resolve(rootPath), ".flowseeker", "cache", "workspace-index.json");
+}
+function fingerprintConfig(config) {
+    return JSON.stringify({
+        include: config.project.include,
+        exclude: config.project.exclude,
+        maxFileSizeKb: config.project.maxFileSizeKb,
+        tokenLimitPerFile,
+        indexVersion
+    });
+}
+//# sourceMappingURL=workspaceIndex.js.map

package/dist/mcp/mcpConfig.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMcpServerConfigs = loadMcpServerConfigs;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+async function loadMcpServerConfigs() {
+    const configured = readConfiguredServers();
+    const workspace = await readWorkspaceMcpServers();
+    return dedupeServers([...configured, ...workspace]).filter(isValidServerConfig);
+}
+function readConfiguredServers() {
+    const value = vscode.workspace.getConfiguration("flowseeker").get("mcp.servers", []);
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((item) => normalizeServerEntry(undefined, item));
+}
+async function readWorkspaceMcpServers() {
+    const folders = vscode.workspace.workspaceFolders;
+    if (!folders?.[0]) {
+        return [];
+    }
+    const configPath = path.join(folders[0].uri.fsPath, ".vscode", "mcp.json");
+    let text;
+    try {
+        text = await fs.readFile(configPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(text);
+        if (!isObject(parsed)) {
+            return [];
+        }
+        const rawServers = parsed.servers;
+        if (Array.isArray(rawServers)) {
+            return rawServers.flatMap((item) => normalizeServerEntry(undefined, item));
+        }
+        if (isObject(rawServers)) {
+            return Object.entries(rawServers).flatMap(([name, item]) => normalizeServerEntry(name, item));
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+}
+function normalizeServerEntry(nameFromKey, value) {
+    if (!isObject(value)) {
+        return [];
+    }
+    const name = stringValue(value.name) ?? nameFromKey;
+    if (!name) {
+        return [];
+    }
+    const hasUrl = Boolean(stringValue(value.url) ?? stringValue(value.uri));
+    const type = stringValue(value.type) === "http" || hasUrl ? "http" : "stdio";
+    return [{
+            name,
+            type,
+            enabled: value.enabled === false ? false : true,
+            command: stringValue(value.command),
+            args: arrayOfStrings(value.args),
+            cwd: stringValue(value.cwd),
+            env: objectOfPrimitiveEnv(value.env),
+            url: stringValue(value.url) ?? stringValue(value.uri),
+            headers: objectOfStrings(value.headers),
+            version: stringValue(value.version)
+        }];
+}
+function isValidServerConfig(server) {
+    if (!server.name.trim()) {
+        return false;
+    }
+    if (server.enabled === false) {
+        return true;
+    }
+    return server.type === "http" ? Boolean(server.url?.trim()) : Boolean(server.command?.trim());
+}
+function dedupeServers(servers) {
+    const seen = new Set();
+    const result = [];
+    for (const server of servers) {
+        const key = server.name.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(server);
+    }
+    return result;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function arrayOfStrings(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.filter((item) => typeof item === "string");
+}
+function objectOfStrings(value) {
+    if (!isObject(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function objectOfPrimitiveEnv(value) {
+    if (!isObject(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => (typeof entry[1] === "string" || typeof entry[1] === "number" || entry[1] === null));
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+//# sourceMappingURL=mcpConfig.js.map