@emeryld/manager 1.3.0 → 1.4.0

package/dist/robot/pack/selection.js

@@ -0,0 +1,44 @@
+import path from 'node:path';
+import { createGlobMatchers, matchesAnyGlob } from './globs.js';
+import { normalizeRelativePath, isPathInside } from './utils.js';
+export function selectCandidateFiles(sourceFiles, settings) {
+    const includeMatchers = createGlobMatchers(settings.includeGlobs);
+    const excludeMatchers = createGlobMatchers(settings.excludeGlobs);
+    const results = [];
+    for (const file of sourceFiles) {
+        if (file.isDeclarationFile)
+            continue;
+        const absolutePath = path.resolve(file.fileName);
+        if (!absolutePath.startsWith(settings.rootDir))
+            continue;
+        if (!isPathInside(absolutePath, settings.scopeDir))
+            continue;
+        const relative = normalizeRelativePath(path.relative(settings.rootDir, absolutePath));
+        if (relative.startsWith('..'))
+            continue;
+        if (!matchesAnyGlob(relative, includeMatchers))
+            continue;
+        if (matchesAnyGlob(relative, excludeMatchers))
+            continue;
+        results.push({ absolutePath, relativePath: relative, sourceFile: file });
+    }
+    return results;
+}
+export function resolveEntrypoints(candidates, settings) {
+    const map = new Map();
+    const entrypointMatchers = createGlobMatchers(settings.entrypoints);
+    for (const candidate of candidates) {
+        if (settings.exportMode === 'all-files') {
+            map.set(candidate.absolutePath, new Set([candidate.relativePath]));
+            continue;
+        }
+        if (matchesAnyGlob(candidate.relativePath, entrypointMatchers)) {
+            map.set(candidate.absolutePath, new Set([candidate.relativePath]));
+        }
+    }
+    if (map.size === 0 && settings.exportMode === 'entrypoints' && candidates.length > 0) {
+        const fallback = candidates.find((entry) => isPathInside(entry.absolutePath, settings.scopeDir)) ?? candidates[0];
+        map.set(fallback.absolutePath, new Set([fallback.relativePath]));
+    }
+    return map;
+}

package/dist/robot/pack/symbols.js

@@ -0,0 +1,309 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { buildSymbolId, normalizeRelativePath, normalizeTypeText, PRINTER } from './utils.js';
+export function collectPublicSymbols(program, checker, candidates, entrypoints, settings) {
+    const compilerOptions = program.getCompilerOptions();
+    const candidatesByPath = new Map(candidates.map((entry) => [entry.absolutePath, entry]));
+    const queue = [...entrypoints.keys()];
+    const moduleEntrypoints = new Map(entrypoints);
+    const visited = new Set();
+    const symbols = new Map();
+    const followReexports = settings.visibility !== 'exported-only';
+    while (queue.length > 0) {
+        const modulePath = queue.shift();
+        if (!modulePath || visited.has(modulePath))
+            continue;
+        visited.add(modulePath);
+        const moduleInfo = candidatesByPath.get(modulePath);
+        if (!moduleInfo)
+            continue;
+        const exposures = moduleEntrypoints.get(modulePath) ?? new Set();
+        const moduleSymbol = checker.getSymbolAtLocation(moduleInfo.sourceFile);
+        if (!moduleSymbol)
+            continue;
+        for (const exportSymbol of checker.getExportsOfModule(moduleSymbol)) {
+            handleSymbol(symbols, exportSymbol, exposures, moduleInfo, checker, settings, Boolean(exportSymbol.flags & ts.SymbolFlags.Alias));
+        }
+        if (settings.visibility === 'all') {
+            includeLocalDeclarations(symbols, moduleInfo, exposures, checker, settings);
+        }
+        if (followReexports) {
+            for (const stmt of moduleInfo.sourceFile.statements) {
+                if (ts.isExportDeclaration(stmt) &&
+                    stmt.moduleSpecifier &&
+                    ts.isStringLiteral(stmt.moduleSpecifier)) {
+                    const resolved = resolveModuleSpecifier(stmt.moduleSpecifier.text, moduleInfo.sourceFile, compilerOptions);
+                    if (resolved && candidatesByPath.has(resolved)) {
+                        ensureModuleExposure(moduleEntrypoints, queue, resolved, exposures);
+                    }
+                }
+            }
+        }
+    }
+    return symbols;
+}
+function includeLocalDeclarations(symbols, moduleInfo, exposures, checker, settings) {
+    for (const stmt of moduleInfo.sourceFile.statements) {
+        const candidates = [];
+        if (ts.isFunctionDeclaration(stmt) ||
+            ts.isClassDeclaration(stmt) ||
+            ts.isInterfaceDeclaration(stmt) ||
+            ts.isTypeAliasDeclaration(stmt) ||
+            ts.isEnumDeclaration(stmt)) {
+            const symbol = stmt.name ? checker.getSymbolAtLocation(stmt.name) : undefined;
+            if (symbol)
+                candidates.push(symbol);
+        }
+        if (ts.isVariableStatement(stmt)) {
+            for (const declaration of stmt.declarationList.declarations) {
+                const symbol = declaration.name
+                    ? checker.getSymbolAtLocation(declaration.name)
+                    : undefined;
+                if (symbol)
+                    candidates.push(symbol);
+            }
+        }
+        for (const candidate of candidates) {
+            handleSymbol(symbols, candidate, exposures, moduleInfo, checker, settings, false);
+        }
+    }
+}
+function handleSymbol(symbols, sourceSymbol, exposures, moduleInfo, checker, settings, isReexport) {
+    const targetSymbol = (sourceSymbol.flags & ts.SymbolFlags.Alias)
+        ? checker.getAliasedSymbol(sourceSymbol)
+        : sourceSymbol;
+    if (!targetSymbol)
+        return;
+    const declaration = targetSymbol.valueDeclaration ?? targetSymbol.declarations?.[0];
+    if (!declaration)
+        return;
+    const kind = determineSymbolKind(targetSymbol, declaration);
+    if (!kind || !settings.includeKinds.includes(kind))
+        return;
+    const name = targetSymbol.getName();
+    const sourcePath = normalizeRelativePath(path.relative(settings.rootDir, declaration.getSourceFile().fileName));
+    const summary = {
+        name,
+        kind,
+        entrypoints: [],
+        modulePath: exposures.values().next().value ?? moduleInfo.relativePath,
+        sourcePath,
+        stableId: buildStableSymbolId(sourcePath, kind, name),
+        signature: buildSymbolSignature(targetSymbol, declaration, checker, kind),
+        isReexport,
+        docTags: extractDocTags(targetSymbol, settings.keepJSDocTags),
+        typeDependencies: [],
+    };
+    const symbolId = buildSymbolId(targetSymbol, declaration);
+    let record = symbols.get(symbolId);
+    if (!record) {
+        record = {
+            symbol: targetSymbol,
+            declaration,
+            summary,
+            entrypoints: new Set(exposures),
+        };
+        record.summary.entrypoints = Array.from(record.entrypoints).sort();
+        symbols.set(symbolId, record);
+        return;
+    }
+    for (const entry of exposures) {
+        record.entrypoints.add(entry);
+    }
+    record.summary.entrypoints = Array.from(record.entrypoints).sort();
+    record.summary.modulePath = record.summary.entrypoints[0] ?? moduleInfo.relativePath;
+}
+function determineSymbolKind(symbol, declaration) {
+    if (ts.isClassLike(declaration))
+        return 'class';
+    if (ts.isFunctionLike(declaration))
+        return 'function';
+    if (ts.isInterfaceDeclaration(declaration))
+        return 'interface';
+    if (ts.isTypeAliasDeclaration(declaration))
+        return 'type-alias';
+    if (ts.isEnumDeclaration(declaration))
+        return 'enum';
+    if (ts.isVariableDeclaration(declaration))
+        return 'const';
+    return undefined;
+}
+function buildSymbolSignature(symbol, declaration, checker, kind) {
+    if (kind === 'function') {
+        return buildFunctionSignature(symbol, declaration, checker);
+    }
+    if (kind === 'class') {
+        return buildClassSignature(declaration, checker);
+    }
+    if (kind === 'const') {
+        return buildConstSignature(symbol, declaration, checker);
+    }
+    return buildTypeSignature(declaration);
+}
+function buildFunctionSignature(symbol, declaration, checker) {
+    const type = checker.getTypeOfSymbolAtLocation(symbol, declaration);
+    const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Call);
+    if (!signatures.length)
+        return symbol.getName();
+    const formatted = signatures
+        .map((signature) => checker.signatureToString(signature))
+        .filter(Boolean);
+    return formatted.join(' | ');
+}
+function buildClassSignature(declaration, checker) {
+    if (!ts.isClassLike(declaration))
+        return declaration.getText();
+    const name = declaration.name?.getText() ?? 'Anonymous';
+    const heritage = declaration.heritageClauses
+        ? declaration.heritageClauses
+            .map((clause) => clause.getText())
+            .join(' ')
+            .trim()
+        : '';
+    const header = `export declare class ${name}${heritage ? ` ${heritage}` : ''}`;
+    const memberParts = [];
+    for (const member of declaration.members) {
+        if (ts.isConstructorDeclaration(member)) {
+            memberParts.push(`constructor(${formatParameters(member.parameters, checker)})`);
+            continue;
+        }
+        if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) {
+            const memberName = member.name?.getText() ?? 'anonymous';
+            const signature = checker.getSignatureFromDeclaration(member);
+            const text = signature
+                ? checker.signatureToString(signature)
+                : `${memberName}()`;
+            memberParts.push(`${memberName}${text.slice(memberName.length)}`);
+            continue;
+        }
+        if (ts.isPropertyDeclaration(member) || ts.isPropertySignature(member)) {
+            const nameText = member.name?.getText() ?? '';
+            const type = member.type
+                ? checker.getTypeAtLocation(member.type)
+                : checker.getTypeAtLocation(member);
+            const typeText = checker.typeToString(type);
+            const optional = member.questionToken ? '?' : '';
+            memberParts.push(`${nameText}${optional}: ${typeText}`);
+        }
+    }
+    const body = memberParts.length ? ` { ${memberParts.join('; ')} }` : ' {}';
+    return `${header}${body}`;
+}
+export function buildClassMemberSignatures(className, modulePath, declaration, checker) {
+    if (!ts.isClassLike(declaration))
+        return [];
+    const entries = [];
+    for (const member of declaration.members) {
+        if (!isClassMemberSignature(member))
+            continue;
+        const memberName = getClassMemberName(member);
+        if (!memberName)
+            continue;
+        const text = buildClassMemberSignatureText(member, checker);
+        if (!text)
+            continue;
+        entries.push({
+            name: memberName,
+            kind: 'function',
+            modulePath,
+            text,
+            parent: className,
+        });
+    }
+    return entries;
+}
+function isClassMemberSignature(member) {
+    return (ts.isMethodDeclaration(member) ||
+        ts.isMethodSignature(member) ||
+        ts.isConstructorDeclaration(member) ||
+        ts.isGetAccessorDeclaration(member) ||
+        ts.isSetAccessorDeclaration(member));
+}
+function getClassMemberName(member) {
+    if (ts.isConstructorDeclaration(member))
+        return 'constructor';
+    const name = member.name;
+    if (!name)
+        return undefined;
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return name.getText();
+}
+function buildClassMemberSignatureText(member, checker) {
+    const signature = checker.getSignatureFromDeclaration(member);
+    if (!signature)
+        return undefined;
+    let text = checker.signatureToString(signature);
+    if (ts.isConstructorDeclaration(member)) {
+        text = text.replace(/^new(?=\s|\()/, 'constructor');
+    }
+    const modifiers = member.modifiers
+        ? member.modifiers.map((modifier) => modifier.getText()).join(' ')
+        : '';
+    const prefix = modifiers ? `${modifiers} ` : '';
+    return `${prefix}${text}`.trim();
+}
+function formatParameters(parameters, checker) {
+    return parameters
+        .map((param) => {
+        const name = param.name.getText();
+        const typeNode = param.type;
+        const type = typeNode ? checker.getTypeAtLocation(typeNode) : checker.getTypeAtLocation(param);
+        const typeText = checker.typeToString(type);
+        const optional = param.questionToken ? '?' : '';
+        return `${name}${optional}: ${typeText}`;
+    })
+        .join(', ');
+}
+function buildConstSignature(symbol, declaration, checker) {
+    const type = checker.getTypeOfSymbolAtLocation(symbol, declaration);
+    return `const ${symbol.getName()}: ${checker.typeToString(type)}`;
+}
+function buildTypeSignature(declaration) {
+    return normalizeTypeText(PRINTER.printNode(ts.EmitHint.Unspecified, declaration, declaration.getSourceFile()));
+}
+function extractDocTags(symbol, keepTags) {
+    const normalized = new Set();
+    const lowerK = keepTags.map((tag) => tag.toLowerCase());
+    for (const tag of symbol.getJsDocTags()) {
+        const name = `@${tag.name ?? ''}`.toLowerCase();
+        if (lowerK.includes(name)) {
+            normalized.add(name);
+        }
+    }
+    return Array.from(normalized);
+}
+function resolveModuleSpecifier(value, source, compilerOptions) {
+    const resolution = ts.resolveModuleName(value, source.fileName, compilerOptions, ts.sys);
+    if (!resolution.resolvedModule)
+        return undefined;
+    return path.resolve(resolution.resolvedModule.resolvedFileName);
+}
+function ensureModuleExposure(moduleEntrypoints, queue, targetPath, exposures) {
+    const existing = moduleEntrypoints.get(targetPath);
+    if (existing) {
+        for (const entry of exposures)
+            existing.add(entry);
+        return;
+    }
+    moduleEntrypoints.set(targetPath, new Set(exposures));
+    queue.push(targetPath);
+}
+function buildStableSymbolId(sourcePath, kind, name) {
+    return `${sourcePath}#${kind}:${name}`;
+}
+export function buildModuleExports(symbols) {
+    const modules = new Map();
+    for (const record of symbols.values()) {
+        for (const entry of record.summary.entrypoints) {
+            const moduleEntry = modules.get(entry) ?? { modulePath: entry, symbols: [] };
+            moduleEntry.symbols.push(record.summary);
+            modules.set(entry, moduleEntry);
+        }
+    }
+    for (const moduleEntry of modules.values()) {
+        moduleEntry.symbols.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    return Array.from(modules.values()).sort((a, b) => a.modulePath.localeCompare(b.modulePath));
+}

package/dist/robot/pack/type-registry.js

@@ -0,0 +1,285 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { normalizeRelativePath, normalizeTypeText, PRINTER } from './utils.js';
+export class TypeRegistry {
+    checker;
+    rootDir;
+    candidateFiles;
+    entries = new Map();
+    depthDirty = true;
+    constructor(checker, rootDir, candidateFiles) {
+        this.checker = checker;
+        this.rootDir = rootDir;
+        this.candidateFiles = candidateFiles;
+    }
+    ensureTypeDeclaration(symbol, declaration) {
+        return this.ensureEntry(symbol, declaration, true);
+    }
+    collectDependenciesForType(key, symbol, declaration) {
+        const dependencies = new Set();
+        const declaredType = this.checker.getDeclaredTypeOfSymbol(symbol);
+        if (declaredType) {
+            this.traverseType(declaredType, key, dependencies, new Set());
+        }
+        return this.sortedArray(dependencies);
+    }
+    collectDependenciesForSymbol(record) {
+        const dependencies = new Set();
+        const type = this.checker.getTypeOfSymbolAtLocation(record.symbol, record.declaration);
+        if (record.summary.kind === 'function') {
+            const signatures = this.checker.getSignaturesOfType(type, ts.SignatureKind.Call);
+            for (const signature of signatures) {
+                this.traverseSignature(signature, undefined, dependencies, new Set());
+            }
+        }
+        else {
+            this.traverseType(type, undefined, dependencies, new Set());
+        }
+        return this.sortedArray(dependencies);
+    }
+    buildDefinitions() {
+        const ordered = this.orderEntries();
+        return ordered.map((entry) => ({
+            name: entry.name,
+            kind: entry.kind,
+            text: entry.text,
+        }));
+    }
+    dropNextDependency() {
+        const candidates = this.getDependencyCandidates();
+        if (!candidates.length)
+            return false;
+        const target = candidates[0];
+        this.entries.delete(target.key);
+        for (const entry of this.entries.values()) {
+            entry.dependencies.delete(target.key);
+        }
+        this.depthDirty = true;
+        return true;
+    }
+    ensureEntry(symbol, declaration, isSurface) {
+        if (!this.isCandidateDeclaration(declaration))
+            return undefined;
+        const kind = this.determineDeclarationKind(declaration);
+        if (!kind)
+            return undefined;
+        const key = this.buildTypeKey(symbol, declaration);
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = {
+                key,
+                name: symbol.getName(),
+                kind,
+                text: normalizeTypeText(PRINTER.printNode(ts.EmitHint.Unspecified, declaration, declaration.getSourceFile())),
+                sourcePath: normalizeRelativePath(path.relative(this.rootDir, declaration.getSourceFile().fileName)),
+                dependencies: new Set(),
+                isSurface,
+            };
+            this.entries.set(key, entry);
+        }
+        else if (isSurface) {
+            entry.isSurface = true;
+        }
+        this.depthDirty = true;
+        return entry.key;
+    }
+    traverseType(type, ownerKey, dependencyNames, visited) {
+        if (!type)
+            return;
+        const typeId = this.getTypeId(type);
+        if (typeId !== undefined && visited.has(typeId))
+            return;
+        if (typeId !== undefined)
+            visited.add(typeId);
+        const referencedSymbol = type.aliasSymbol ?? type.getSymbol();
+        if (referencedSymbol) {
+            const declaration = referencedSymbol.valueDeclaration ?? referencedSymbol.declarations?.[0];
+            if (declaration) {
+                const childKey = this.ensureEntry(referencedSymbol, declaration, false);
+                if (childKey && ownerKey && ownerKey !== childKey) {
+                    this.entries.get(ownerKey)?.dependencies.add(childKey);
+                }
+                if (childKey) {
+                    dependencyNames.add(this.entries.get(childKey).name);
+                }
+            }
+        }
+        if (type.isUnionOrIntersection()) {
+            for (const part of type.types) {
+                this.traverseType(part, ownerKey, dependencyNames, visited);
+            }
+        }
+        const reference = type;
+        const typeArguments = reference.typeArguments ?? type.aliasTypeArguments;
+        if (typeArguments) {
+            for (const arg of typeArguments) {
+                this.traverseType(arg, ownerKey, dependencyNames, visited);
+            }
+        }
+        if (reference.target) {
+            this.traverseType(reference.target, ownerKey, dependencyNames, visited);
+        }
+        for (const signature of type.getCallSignatures()) {
+            this.traverseSignature(signature, ownerKey, dependencyNames, visited);
+        }
+        for (const signature of type.getConstructSignatures()) {
+            this.traverseSignature(signature, ownerKey, dependencyNames, visited);
+        }
+        const properties = type.getProperties();
+        for (const property of properties) {
+            const decl = property.valueDeclaration ?? property.declarations?.[0];
+            if (!decl)
+                continue;
+            const propType = this.checker.getTypeAtLocation(decl);
+            this.traverseType(propType, ownerKey, dependencyNames, visited);
+        }
+        const stringIndex = type.getStringIndexType();
+        if (stringIndex)
+            this.traverseType(stringIndex, ownerKey, dependencyNames, visited);
+        const numberIndex = type.getNumberIndexType();
+        if (numberIndex)
+            this.traverseType(numberIndex, ownerKey, dependencyNames, visited);
+        for (const base of type.getBaseTypes() ?? []) {
+            this.traverseType(base, ownerKey, dependencyNames, visited);
+        }
+    }
+    traverseSignature(signature, ownerKey, dependencyNames, visited) {
+        this.traverseType(signature.getReturnType(), ownerKey, dependencyNames, visited);
+        for (const parameter of signature.getParameters()) {
+            const decl = parameter.valueDeclaration ?? parameter.declarations?.[0];
+            if (!decl)
+                continue;
+            this.traverseType(this.checker.getTypeAtLocation(decl), ownerKey, dependencyNames, visited);
+        }
+        for (const typeParam of signature.typeParameters ?? []) {
+            const constraint = typeParam.getConstraint();
+            if (constraint) {
+                this.traverseType(constraint, ownerKey, dependencyNames, visited);
+            }
+        }
+    }
+    getTypeId(type) {
+        return type.id;
+    }
+    isCandidateDeclaration(declaration) {
+        const file = path.resolve(declaration.getSourceFile().fileName);
+        return this.candidateFiles.has(file);
+    }
+    determineDeclarationKind(declaration) {
+        if (ts.isInterfaceDeclaration(declaration))
+            return 'interface';
+        if (ts.isTypeAliasDeclaration(declaration))
+            return 'type-alias';
+        if (ts.isEnumDeclaration(declaration))
+            return 'enum';
+        return undefined;
+    }
+    buildTypeKey(symbol, declaration) {
+        const relative = normalizeRelativePath(path.relative(this.rootDir, declaration.getSourceFile().fileName));
+        return `${symbol.getName()}@${relative}:${declaration.getStart()}`;
+    }
+    orderEntries() {
+        const dependencyCounts = new Map();
+        const dependents = new Map();
+        for (const entry of this.entries.values()) {
+            const filtered = Array.from(entry.dependencies).filter((dep) => this.entries.has(dep));
+            dependencyCounts.set(entry.key, filtered.length);
+            for (const dep of filtered) {
+                const parents = dependents.get(dep) ?? new Set();
+                parents.add(entry.key);
+                dependents.set(dep, parents);
+            }
+        }
+        const compare = (a, b) => {
+            if (a.name !== b.name)
+                return a.name.localeCompare(b.name);
+            return a.sourcePath.localeCompare(b.sourcePath);
+        };
+        const available = Array.from(this.entries.values()).filter((entry) => (dependencyCounts.get(entry.key) ?? 0) === 0);
+        available.sort(compare);
+        const ordered = [];
+        const processed = new Set();
+        while (available.length > 0) {
+            const current = available.shift();
+            ordered.push(current);
+            processed.add(current.key);
+            const children = dependents.get(current.key);
+            if (children) {
+                for (const childKey of Array.from(children)) {
+                    const count = (dependencyCounts.get(childKey) ?? 0) - 1;
+                    dependencyCounts.set(childKey, count);
+                    if (count <= 0 && !processed.has(childKey)) {
+                        const child = this.entries.get(childKey);
+                        if (child) {
+                            available.push(child);
+                        }
+                    }
+                }
+                dependents.delete(current.key);
+            }
+            available.sort(compare);
+        }
+        if (ordered.length < this.entries.size) {
+            const remaining = Array.from(this.entries.values()).filter((entry) => !processed.has(entry.key));
+            remaining.sort(compare);
+            ordered.push(...remaining);
+        }
+        return ordered;
+    }
+    computeDepths() {
+        const surfaceKeys = new Set();
+        for (const entry of this.entries.values()) {
+            if (entry.isSurface)
+                surfaceKeys.add(entry.key);
+        }
+        for (const entry of this.entries.values()) {
+            entry.depth = undefined;
+        }
+        const queue = [];
+        for (const key of surfaceKeys) {
+            const entry = this.entries.get(key);
+            if (entry) {
+                entry.depth = 0;
+                queue.push(key);
+            }
+        }
+        while (queue.length) {
+            const parentKey = queue.shift();
+            const parent = this.entries.get(parentKey);
+            if (!parent)
+                continue;
+            for (const dependencyKey of parent.dependencies) {
+                const child = this.entries.get(dependencyKey);
+                if (!child)
+                    continue;
+                const depthCandidate = (parent.depth ?? 0) + 1;
+                if (child.depth === undefined || depthCandidate < child.depth) {
+                    child.depth = depthCandidate;
+                    queue.push(child.key);
+                }
+            }
+        }
+        this.depthDirty = false;
+    }
+    ensureDepths() {
+        if (this.depthDirty) {
+            this.computeDepths();
+        }
+    }
+    getDependencyCandidates() {
+        this.ensureDepths();
+        const candidates = Array.from(this.entries.values()).filter((entry) => !entry.isSurface);
+        candidates.sort((a, b) => {
+            const depthDiff = (b.depth ?? 0) - (a.depth ?? 0);
+            if (depthDiff !== 0)
+                return depthDiff;
+            if (a.name !== b.name)
+                return a.name.localeCompare(b.name);
+            return a.sourcePath.localeCompare(b.sourcePath);
+        });
+        return candidates;
+    }
+    sortedArray(set) {
+        return Array.from(set).sort();
+    }
+}

package/dist/robot/pack/types.js

@@ -0,0 +1,48 @@
+export const ROBOT_PACK_SYMBOL_KINDS = [
+    'function',
+    'class',
+    'interface',
+    'type-alias',
+    'enum',
+    'const',
+];
+export const ROBOT_PACK_DEFAULT_SETTINGS = {
+    rootDir: '',
+    scopeDir: '',
+    reportMethod: 'editor',
+    includeGlobs: ['src/**/*.{ts,tsx}'],
+    excludeGlobs: [
+        '**/*.test.*',
+        '**/*.spec.*',
+        '**/__tests__/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/*.d.ts',
+    ],
+    entrypoints: ['src/index.ts', 'src/**/index.ts'],
+    exportMode: 'all-files',
+    visibility: 'all',
+    includeKinds: [...ROBOT_PACK_SYMBOL_KINDS],
+    closure: 'surface+deps',
+    maxExemplars: 8,
+    tokenBudget: undefined,
+    preferTypeSurface: true,
+    exemplarHeuristics: {
+        usage: 6,
+        boundary: 1.2,
+        flow: 1.3,
+        clarity: 0.8,
+        redundancy: 0.6,
+        tau: 280,
+    },
+    keepJSDocTags: [
+        '@deprecated',
+        '@throws',
+        '@pure',
+        '@sideEffects',
+        '@internal',
+        '@public',
+        '@experimental',
+        '@llm',
+    ],
+};