@emeryld/manager 1.3.0 → 1.4.0

package/dist/robot/pack/exemplars.js

@@ -0,0 +1,573 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { buildSymbolId, estimateTokens, normalizeRelativePath } from './utils.js';
+const MAX_CHUNK_TOKENS = 300;
+const CALL_SITE_LIMIT = 2;
+const BUCKET_KEYWORDS = {
+    orchestration: ['pipeline', 'orchestrate', 'flow', 'step', 'sequence', 'dispatch', 'run', 'handle', 'context'],
+    configuration: ['config', 'setting', 'settings', 'normalize', 'defaults', 'option', 'resolve', 'merge', 'env', 'pref'],
+    parsing: ['parse', 'validation', 'validate', 'schema', 'input', 'payload', 'deserialize', 'decode', 'token', 'assert'],
+    selection: ['filter', 'select', 'choose', 'pick', 'match', 'find', 'sort', 'candidate', 'decide', 'rank'],
+    core: ['compute', 'calculate', 'algorithm', 'strategy', 'engine', 'transform', 'score', 'aggregate', 'map', 'reduce'],
+    io: ['fs', 'readfile', 'writefile', 'console', 'log', 'stdout', 'stderr', 'process', 'argv', 'cli', 'command', 'output', 'serialize', 'deserialize', 'fetch', 'http', 'request', 'response', 'file', 'stream'],
+};
+const BUCKET_LABELS = {
+    orchestration: 'orchestration / pipeline',
+    configuration: 'configuration / normalization',
+    parsing: 'parsing / validation',
+    selection: 'selection / filtering',
+    core: 'core domain algorithm',
+    io: 'I/O boundary',
+};
+const BOUNDARY_KEYWORDS = [
+    'config',
+    'setting',
+    'cli',
+    'command',
+    'option',
+    'env',
+    'fs',
+    'read',
+    'write',
+    'console',
+    'output',
+    'serialize',
+    'deserialize',
+    'file',
+    'http',
+    'request',
+    'response',
+    'stream',
+];
+export function buildExemplarCandidates(symbols, candidates, settings, checker) {
+    const recordBySymbol = new Map();
+    const recordById = new Map();
+    const declarationOwners = new Map();
+    for (const record of symbols.values()) {
+        const identifier = buildSymbolId(record.symbol, record.declaration);
+        recordBySymbol.set(record.symbol, record);
+        recordById.set(identifier, record);
+        declarationOwners.set(record.declaration, record);
+    }
+    const { callSites, callGraph } = collectCallSiteData(candidates, declarationOwners, recordBySymbol, checker, settings.rootDir);
+    const flowPath = buildFlowPath(recordById, callGraph);
+    const flowSymbolIds = new Set(flowPath?.map((entry) => buildSymbolId(entry.symbol, entry.declaration)) ?? []);
+    const chunks = [];
+    if (flowPath && flowPath.length >= 3) {
+        const flowChunk = createFlowChunk(flowPath, settings.exemplarHeuristics);
+        if (flowChunk)
+            chunks.push(flowChunk);
+    }
+    for (const record of symbols.values()) {
+        const recordChunks = buildChunksForRecord(record, callSites, flowSymbolIds, settings.exemplarHeuristics);
+        chunks.push(...recordChunks);
+    }
+    return chunks.sort((a, b) => b.finalScore - a.finalScore);
+}
+export function selectExemplars(candidates, settings) {
+    const heuristics = settings.exemplarHeuristics;
+    const maxTokens = settings.tokenBudget ?? Number.POSITIVE_INFINITY;
+    const maxExemplars = settings.maxExemplars;
+    const highPriorityBuckets = ['orchestration', 'configuration', 'core', 'io'];
+    const bucketCounts = new Map();
+    const bucketCoverage = new Set();
+    const selectedSymbols = new Set();
+    const selected = [];
+    let usedTokens = 0;
+    const pool = [...candidates];
+    const flowIndex = pool.findIndex((chunk) => chunk.isFlow);
+    if (flowIndex >= 0) {
+        const [flowChunk] = pool.splice(flowIndex, 1);
+        if (tryAddChunk(flowChunk)) {
+            bucketCoverage.add('orchestration');
+        }
+        else {
+            pool.push(flowChunk);
+        }
+    }
+    for (const bucket of highPriorityBuckets) {
+        if (bucket === 'orchestration' && bucketCoverage.has('orchestration'))
+            continue;
+        if (selected.length >= maxExemplars)
+            break;
+        const candidate = pool.find((chunk) => chunk.purposeBuckets.includes(bucket) && canAddChunk(chunk));
+        if (candidate) {
+            if (tryAddChunk(candidate)) {
+                bucketCoverage.add(bucket);
+                const index = pool.indexOf(candidate);
+                if (index >= 0)
+                    pool.splice(index, 1);
+            }
+        }
+    }
+    for (const candidate of [...pool]) {
+        if (selected.length >= maxExemplars)
+            break;
+        if (!canAddChunk(candidate))
+            continue;
+        const penalty = calcRedundancyPenalty(candidate, selectedSymbols, heuristics);
+        if (penalty <= 0.1)
+            continue;
+        if (!tryAddChunk(candidate))
+            continue;
+    }
+    return selected.map((chunk) => ({
+        name: chunk.name,
+        kind: chunk.kind,
+        modulePath: chunk.modulePath,
+        score: chunk.finalScore,
+        body: chunk.body,
+        tokenCount: chunk.tokenCount,
+        purposeBuckets: compactPurposeBuckets(chunk.purposeBuckets),
+        metadata: {
+            purpose: chunk.metadata.purpose,
+            whenRelevant: chunk.metadata.whenRelevant,
+        },
+    }));
+    function canAddChunk(chunk) {
+        if (selected.length >= maxExemplars)
+            return false;
+        if (usedTokens + chunk.tokenCount > maxTokens)
+            return false;
+        const bucket = getPrimaryBucket(chunk);
+        if ((bucketCounts.get(bucket) ?? 0) >= 2)
+            return false;
+        return chunk.finalScore > 0;
+    }
+    function tryAddChunk(chunk) {
+        if (!canAddChunk(chunk))
+            return false;
+        selected.push(chunk);
+        usedTokens += chunk.tokenCount;
+        const bucket = getPrimaryBucket(chunk);
+        bucketCounts.set(bucket, (bucketCounts.get(bucket) ?? 0) + 1);
+        for (const purpose of chunk.purposeBuckets) {
+            if (highPriorityBuckets.includes(purpose)) {
+                bucketCoverage.add(purpose);
+            }
+        }
+        for (const symbol of chunk.symbolsShown) {
+            selectedSymbols.add(symbol);
+        }
+        const poolIndex = pool.indexOf(chunk);
+        if (poolIndex >= 0) {
+            pool.splice(poolIndex, 1);
+        }
+        return true;
+    }
+    function getPrimaryBucket(chunk) {
+        return chunk.purposeBuckets[0] ?? 'core';
+    }
+    function calcRedundancyPenalty(chunk, selectedSymbols, heuristics) {
+        if (!selectedSymbols.size)
+            return 1;
+        const overlap = chunk.symbolsShown.filter((symbol) => selectedSymbols.has(symbol)).length;
+        if (!overlap)
+            return 1;
+        const ratio = overlap / Math.max(1, chunk.symbolsShown.length);
+        const penalty = 1 - heuristics.redundancy * ratio;
+        return Math.max(0.1, penalty);
+    }
+}
+function collectCallSiteData(candidates, declarationOwners, exportedSymbolBySymbol, checker, rootDir) {
+    const callSites = new Map();
+    const callGraph = new Map();
+    for (const candidate of candidates) {
+        const relativePath = normalizeRelativePath(path.relative(rootDir, candidate.absolutePath));
+        visit(candidate.sourceFile, undefined, relativePath);
+    }
+    return { callSites, callGraph };
+    function visit(node, owner, modulePath) {
+        const nextOwner = declarationOwners.get(node) ?? owner;
+        if (ts.isCallExpression(node)) {
+            recordCall(node, nextOwner, modulePath);
+        }
+        ts.forEachChild(node, (child) => visit(child, nextOwner, modulePath));
+    }
+    function recordCall(node, owner, modulePath) {
+        const symbol = checker.getSymbolAtLocation(node.expression);
+        if (!symbol)
+            return;
+        const resolved = (symbol.flags & ts.SymbolFlags.Alias) ? checker.getAliasedSymbol(symbol) : symbol;
+        if (!resolved)
+            return;
+        const target = exportedSymbolBySymbol.get(resolved);
+        if (!target)
+            return;
+        const calleeId = buildSymbolId(target.symbol, target.declaration);
+        const callerId = owner ? buildSymbolId(owner.symbol, owner.declaration) : undefined;
+        if (owner && callerId && callerId !== calleeId) {
+            const edges = callGraph.get(callerId) ?? new Set();
+            edges.add(calleeId);
+            callGraph.set(callerId, edges);
+        }
+        const anchor = findStatementAncestor(node) ?? node;
+        const statementText = limitSnippet(normalizeSnippet(anchor.getText()));
+        const argumentPreview = buildArgumentPreview(node.arguments);
+        const hasGuard = hasGuardingAncestor(node);
+        const mentionsError = /error|throw|fail/i.test(statementText);
+        const info = {
+            callerId,
+            callerName: owner ? owner.summary.name : `module:${modulePath}`,
+            sourcePath: modulePath,
+            statementText,
+            argumentPreview,
+            hasGuard,
+            mentionsError,
+            priority: calcCallSitePriority(hasGuard, mentionsError, argumentPreview, node.arguments.length),
+        };
+        const bucket = callSites.get(calleeId) ?? [];
+        bucket.push(info);
+        callSites.set(calleeId, bucket);
+    }
+}
+function calcCallSitePriority(hasGuard, mentionsError, argumentPreview, argumentCount) {
+    let score = hasGuard ? 1 : 0;
+    if (mentionsError)
+        score += 0.7;
+    if (argumentCount > 0)
+        score += 0.4;
+    if (argumentPreview)
+        score += Math.min(0.3, argumentPreview.length / 80);
+    return score;
+}
+function buildFlowPath(recordById, callGraph) {
+    let best;
+    for (const [id, record] of recordById.entries()) {
+        if (!record.entrypoints || record.entrypoints.size === 0)
+            continue;
+        const path = walkFlow(record, new Set([id]), recordById, callGraph, 0);
+        if (path.length >= 3 && (!best || path.length > best.length)) {
+            best = path;
+        }
+    }
+    return best?.slice(0, 6);
+}
+function walkFlow(record, visited, recordById, callGraph, depth) {
+    const currentId = buildSymbolId(record.symbol, record.declaration);
+    if (depth >= 5)
+        return [record];
+    const neighbors = callGraph.get(currentId);
+    let best;
+    if (neighbors) {
+        for (const neighborId of neighbors) {
+            if (visited.has(neighborId))
+                continue;
+            const neighbor = recordById.get(neighborId);
+            if (!neighbor)
+                continue;
+            visited.add(neighborId);
+            const path = walkFlow(neighbor, visited, recordById, callGraph, depth + 1);
+            visited.delete(neighborId);
+            if (path.length && (!best || path.length > best.length)) {
+                best = path;
+            }
+        }
+    }
+    if (best && best.length) {
+        return [record, ...best];
+    }
+    return [record];
+}
+function createFlowChunk(path, heuristics) {
+    if (!path.length)
+        return undefined;
+    const stepBudget = Math.max(20, Math.floor((MAX_CHUNK_TOKENS - path.length * 5) / path.length));
+    const snippets = path.map((record, index) => {
+        const snippet = limitSnippet(normalizeSnippet(record.declaration.getText()), stepBudget);
+        return `// Step ${index + 1}: ${record.summary.name}\n${snippet}`;
+    });
+    const body = limitSnippet(snippets.join('\n\n'), MAX_CHUNK_TOKENS);
+    if (!body)
+        return undefined;
+    const entryName = path[0].summary.name;
+    const exitName = path[path.length - 1].summary.name;
+    const symbols = path.map((record) => record.summary.name);
+    const metadata = buildChunkMetadata(path[0], 'flow', ['orchestration'], { entrypoint: entryName, exit: exitName, symbols });
+    const chunkBase = {
+        id: `flow:${symbols.join('→')}`,
+        name: `${entryName} flow`,
+        kind: path[0].summary.kind,
+        modulePath: path[0].summary.sourcePath,
+        chunkType: 'flow',
+        body,
+        tokenCount: Math.max(1, estimateTokens(body)),
+        purposeBuckets: ['orchestration'],
+        metadata,
+        usageScore: 2.2,
+        boundaryScore: 0.7,
+        flowScore: 1,
+        clarityScore: 0.8,
+        symbolsShown: symbols,
+        isFlow: true,
+    };
+    return createChunkCandidate(chunkBase, heuristics);
+}
+function buildChunksForRecord(record, callSites, flowSymbolIds, heuristics) {
+    const recordId = buildSymbolId(record.symbol, record.declaration);
+    const modulePath = record.summary.sourcePath;
+    const symbolCallSites = callSites.get(recordId) ?? [];
+    const hasEntrypoint = record.entrypoints.size > 0;
+    const chunks = [];
+    const signatureBody = limitSnippet(normalizeSnippet(record.declaration.getText()));
+    if (signatureBody) {
+        const purposeBuckets = classifyPurpose(signatureBody);
+        const metadata = buildChunkMetadata(record, 'signature', purposeBuckets, {});
+        const chunkBase = {
+            id: `${recordId}:signature`,
+            name: record.summary.name,
+            kind: record.summary.kind,
+            modulePath,
+            chunkType: 'signature',
+            body: signatureBody,
+            tokenCount: estimateTokens(signatureBody),
+            purposeBuckets,
+            metadata,
+            usageScore: calcUsageScore(symbolCallSites.length, 'signature', 0, hasEntrypoint),
+            boundaryScore: calcBoundaryScore(signatureBody),
+            flowScore: flowSymbolIds.has(recordId) ? 1 : 0,
+            clarityScore: calcClarityScore(signatureBody, record, 'signature'),
+            symbolsShown: [record.summary.name],
+            recordId,
+        };
+        chunks.push(createChunkCandidate(chunkBase, heuristics));
+    }
+    const decisionNode = findDecisionNode(record.declaration);
+    if (decisionNode) {
+        const decisionBody = limitSnippet(normalizeSnippet(decisionNode.getText()));
+        if (decisionBody) {
+            const purposeBuckets = classifyPurpose(decisionBody);
+            const metadata = buildChunkMetadata(record, 'decision', purposeBuckets, {});
+            const chunkBase = {
+                id: `${recordId}:decision`,
+                name: record.summary.name,
+                kind: record.summary.kind,
+                modulePath,
+                chunkType: 'decision',
+                body: decisionBody,
+                tokenCount: estimateTokens(decisionBody),
+                purposeBuckets,
+                metadata,
+                usageScore: calcUsageScore(symbolCallSites.length, 'decision', 0, hasEntrypoint),
+                boundaryScore: calcBoundaryScore(decisionBody),
+                flowScore: flowSymbolIds.has(recordId) ? 1 : 0,
+                clarityScore: calcClarityScore(decisionBody, record, 'decision'),
+                symbolsShown: [record.summary.name],
+                recordId,
+            };
+            chunks.push(createChunkCandidate(chunkBase, heuristics));
+        }
+    }
+    if (symbolCallSites.length) {
+        const topSites = [...symbolCallSites]
+            .sort((a, b) => b.priority - a.priority)
+            .slice(0, CALL_SITE_LIMIT);
+        for (const site of topSites) {
+            const snippet = limitSnippet(site.statementText);
+            if (!snippet)
+                continue;
+            const purposeBuckets = classifyPurpose(snippet);
+            const contextSymbols = [record.summary.name];
+            if (site.callerName)
+                contextSymbols.push(site.callerName);
+            const metadata = buildChunkMetadata(record, 'usage', purposeBuckets, {
+                callerName: site.callerName,
+                argumentPreview: site.argumentPreview,
+                symbols: contextSymbols,
+            });
+            const uniqueSymbols = Array.from(new Set(contextSymbols));
+            const chunkBase = {
+                id: `${recordId}:usage:${site.sourcePath}:${snippet.slice(0, 16)}`,
+                name: record.summary.name,
+                kind: record.summary.kind,
+                modulePath: site.sourcePath,
+                chunkType: 'usage',
+                body: snippet,
+                tokenCount: estimateTokens(snippet),
+                purposeBuckets,
+                metadata,
+                usageScore: calcUsageScore(symbolCallSites.length, 'usage', site.priority, hasEntrypoint),
+                boundaryScore: calcBoundaryScore(snippet),
+                flowScore: site.callerId && flowSymbolIds.has(site.callerId) ? 1 : 0,
+                clarityScore: calcClarityScore(snippet, record, 'usage'),
+                symbolsShown: uniqueSymbols,
+                recordId,
+            };
+            chunks.push(createChunkCandidate(chunkBase, heuristics));
+        }
+    }
+    return chunks;
+}
+function createChunkCandidate(options, heuristics) {
+    const chunk = {
+        ...options,
+        finalScore: 0,
+    };
+    chunk.finalScore = scoreChunk(chunk, heuristics);
+    return chunk;
+}
+function scoreChunk(chunk, heuristics) {
+    const baseScore = chunk.usageScore * heuristics.usage +
+        chunk.boundaryScore * heuristics.boundary +
+        chunk.flowScore * heuristics.flow +
+        chunk.clarityScore * heuristics.clarity;
+    const penalty = 1 + chunk.tokenCount / heuristics.tau;
+    return baseScore / penalty;
+}
+function classifyPurpose(body) {
+    const normalized = body.toLowerCase();
+    const buckets = [];
+    for (const bucket of Object.keys(BUCKET_KEYWORDS)) {
+        const keywords = BUCKET_KEYWORDS[bucket];
+        if (keywords.some((keyword) => normalized.includes(keyword))) {
+            buckets.push(bucket);
+        }
+    }
+    if (!buckets.length)
+        buckets.push('core');
+    return buckets;
+}
+function describePurpose(buckets) {
+    const unique = Array.from(new Set(buckets));
+    return unique.map((bucket) => BUCKET_LABELS[bucket]).join(' · ');
+}
+function buildChunkMetadata(record, chunkType, purposeBuckets, context) {
+    const purpose = describePurpose(purposeBuckets);
+    const whenRelevant = buildWhenRelevant(record, chunkType, purpose, context);
+    const symbolSet = new Set(context.symbols ?? []);
+    symbolSet.add(record.summary.name);
+    if (context.callerName)
+        symbolSet.add(context.callerName);
+    return {
+        purpose,
+        whenRelevant,
+        symbolsShown: Array.from(symbolSet),
+    };
+}
+function buildWhenRelevant(record, chunkType, purposeLabel, context) {
+    switch (chunkType) {
+        case 'signature':
+            return `When you need to recall how ${record.summary.name} is declared for ${purposeLabel}.`;
+        case 'decision':
+            return `When you want to inspect the ${purposeLabel} guard or validation inside ${record.summary.name}.`;
+        case 'usage': {
+            const caller = context.callerName ?? 'an upstream module';
+            const args = context.argumentPreview ? ` with ${context.argumentPreview}` : '';
+            return `When you need to see how ${record.summary.name} is invoked by ${caller}${args}.`;
+        }
+        case 'flow':
+            return `When you need a compact ${purposeLabel} tour from ${context.entrypoint ?? 'entrypoint'} → ${context.exit ?? 'output'}.`;
+        default:
+            return `When you need to understand ${record.summary.name} for ${purposeLabel}.`;
+    }
+}
+function calcUsageScore(callSiteCount, chunkType, callSitePriority, hasEntrypoint) {
+    let score = Math.min(1, callSiteCount * 0.2);
+    if (chunkType === 'usage')
+        score += 1;
+    score += callSitePriority ?? 0;
+    if (hasEntrypoint)
+        score += 0.3;
+    return Math.min(3, score);
+}
+function calcBoundaryScore(body) {
+    const snapshot = body.toLowerCase();
+    return BOUNDARY_KEYWORDS.some((keyword) => snapshot.includes(keyword)) ? 1 : 0;
+}
+function calcClarityScore(body, record, chunkType) {
+    const docBonus = Math.min(1, record.summary.docTags.length * 0.25);
+    const errorBonus = /error|throw|fail|warn/i.test(body) ? 0.25 : 0;
+    const usageBonus = chunkType === 'usage' ? 0.1 : 0;
+    return Math.min(1, docBonus + errorBonus + usageBonus);
+}
+function normalizeSnippet(text) {
+    return text
+        .replace(/\r?\n/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function limitSnippet(text, maxTokens = MAX_CHUNK_TOKENS) {
+    if (!text)
+        return '';
+    if (estimateTokens(text) <= maxTokens)
+        return text;
+    const maxChars = Math.floor(maxTokens * 4);
+    return `${text.slice(0, maxChars).trimEnd()}…`;
+}
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength).trimEnd()}…`;
+}
+function compactPurposeBuckets(buckets) {
+    const seen = new Set();
+    const compacted = [];
+    for (const bucket of buckets) {
+        if (seen.has(bucket))
+            continue;
+        seen.add(bucket);
+        compacted.push(bucket);
+        if (compacted.length >= 3)
+            break;
+    }
+    return compacted;
+}
+function findDecisionNode(node) {
+    let found;
+    ts.forEachChild(node, (child) => {
+        if (found)
+            return;
+        if (isDecisionNode(child)) {
+            found = child;
+            return;
+        }
+        const nested = findDecisionNode(child);
+        if (nested)
+            found = nested;
+    });
+    return found;
+}
+function isDecisionNode(node) {
+    return (ts.isIfStatement(node) ||
+        ts.isSwitchStatement(node) ||
+        ts.isTryStatement(node) ||
+        ts.isCatchClause(node) ||
+        ts.isForStatement(node) ||
+        ts.isForOfStatement(node) ||
+        ts.isForInStatement(node) ||
+        ts.isWhileStatement(node) ||
+        ts.isDoStatement(node) ||
+        ts.isConditionalExpression(node) ||
+        ts.isThrowStatement(node));
+}
+function findStatementAncestor(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isStatement(current))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+}
+function hasGuardingAncestor(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isIfStatement(current) ||
+            ts.isTryStatement(current) ||
+            ts.isCatchClause(current) ||
+            ts.isConditionalExpression(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function buildArgumentPreview(argumentsArray) {
+    if (!argumentsArray.length)
+        return '';
+    const preview = argumentsArray
+        .map((arg) => normalizeSnippet(arg.getText()))
+        .filter(Boolean)
+        .join(', ');
+    return truncateText(preview, 60);
+}

package/dist/robot/pack/globs.js

@@ -0,0 +1,119 @@
+// globs.ts
+const ESCAPE_REGEX = /[.+^${}()|[\]\\]/g;
+function escapeLiteral(value) {
+    return value.replace(ESCAPE_REGEX, '\\$&');
+}
+function normalizePatternInput(value) {
+    let normalized = value.replace(/\\/g, '/').trim();
+    if (normalized.startsWith('./'))
+        normalized = normalized.slice(2);
+    while (normalized.startsWith('/'))
+        normalized = normalized.slice(1);
+    while (normalized.endsWith('/') && normalized.length > 1)
+        normalized = normalized.slice(0, -1);
+    return normalized;
+}
+function normalizeTargetPath(value) {
+    let normalized = value.replace(/\\/g, '/');
+    if (normalized.startsWith('./'))
+        normalized = normalized.slice(2);
+    while (normalized.startsWith('/'))
+        normalized = normalized.slice(1);
+    while (normalized.endsWith('/') && normalized.length > 1)
+        normalized = normalized.slice(0, -1);
+    return normalized;
+}
+// --- brace expansion: a{b,c}d -> [abd, acd]
+function splitAlternatives(value) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < value.length; i += 1) {
+        const ch = value[i];
+        if (ch === '{')
+            depth += 1;
+        else if (ch === '}')
+            depth = Math.max(0, depth - 1);
+        else if (ch === ',' && depth === 0) {
+            parts.push(value.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(value.slice(start));
+    return parts.map((p) => p.trim()).filter(Boolean);
+}
+function expandBraces(pattern) {
+    const start = pattern.indexOf('{');
+    if (start === -1)
+        return [pattern];
+    let depth = 0;
+    for (let i = start; i < pattern.length; i += 1) {
+        const ch = pattern[i];
+        if (ch === '{')
+            depth += 1;
+        else if (ch === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                const inner = pattern.slice(start + 1, i);
+                const alts = splitAlternatives(inner);
+                const prefix = pattern.slice(0, start);
+                const suffix = pattern.slice(i + 1);
+                const out = [];
+                for (const alt of alts) {
+                    out.push(...expandBraces(`${prefix}${alt}${suffix}`));
+                }
+                return out;
+            }
+        }
+    }
+    return [pattern]; // unbalanced braces: treat literally
+}
+function globToRegExp(pattern) {
+    let regex = '';
+    let index = 0;
+    while (index < pattern.length) {
+        const char = pattern[index];
+        if (char === '*') {
+            const next = pattern[index + 1];
+            if (next === '*') {
+                regex += '.*';
+                index += 2;
+                continue;
+            }
+            regex += '[^/]*';
+            index += 1;
+            continue;
+        }
+        if (char === '?') {
+            regex += '[^/]';
+            index += 1;
+            continue;
+        }
+        if (char === '/') {
+            regex += '/';
+            index += 1;
+            continue;
+        }
+        regex += escapeLiteral(char);
+        index += 1;
+    }
+    return regex;
+}
+export function createGlobMatchers(patterns) {
+    const matchers = [];
+    for (const raw of patterns) {
+        const normalized = normalizePatternInput(raw);
+        if (!normalized)
+            continue;
+        for (const expanded of expandBraces(normalized)) {
+            matchers.push(new RegExp(`^${globToRegExp(expanded)}$`));
+        }
+    }
+    return matchers;
+}
+export function matchesAnyGlob(value, matchers) {
+    if (!matchers.length)
+        return true;
+    const normalized = normalizeTargetPath(value);
+    return matchers.some((matcher) => matcher.test(normalized));
+}