unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/world/properties.d.ts

@@ -1,200 +0,0 @@
-import type { JsonObject } from '../../model.js';
-export declare const P: {
-    levelName: JsonObject;
-    levelPath: JsonObject;
-    parentLevel: JsonObject;
-    sublevelName: JsonObject;
-    sublevelPath: JsonObject;
-    bCreateWorldPartition: JsonObject;
-    bUseExternalActors: JsonObject;
-    streamingMethod: {
-        type: string;
-        enum: string[];
-        description: string;
-    };
-    bShouldBeVisible: JsonObject;
-    bShouldBlockOnLoad: JsonObject;
-    bDisableDistanceStreaming: JsonObject;
-    streamingDistance: JsonObject;
-    streamingUsage: JsonObject;
-    createVolume: JsonObject;
-    bEnableWorldPartition: JsonObject;
-    gridCellSize: JsonObject;
-    loadingRange: JsonObject;
-    gridName: JsonObject;
-    gridPriority: JsonObject;
-    dataLayerName: JsonObject;
-    bIsInitiallyVisible: JsonObject;
-    bIsInitiallyLoaded: JsonObject;
-    dataLayerType: JsonObject;
-    actorName: JsonObject;
-    actorPath: JsonObject;
-    hlodLayerName: JsonObject;
-    hlodLayerPath: JsonObject;
-    bIsSpatiallyLoaded: JsonObject;
-    cellSize: JsonObject;
-    loadingDistance: JsonObject;
-    volumeName: JsonObject;
-    volumeLocation: JsonObject;
-    volumeExtent: JsonObject;
-    location: JsonObject;
-    rotation: JsonObject;
-    extent: JsonObject;
-    sphereRadius: JsonObject;
-    capsuleRadius: JsonObject;
-    capsuleHalfHeight: JsonObject;
-    boxExtent: JsonObject;
-    bPainCausing: JsonObject;
-    damagePerSec: JsonObject;
-    bWaterVolume: JsonObject;
-    fluidFriction: JsonObject;
-    terminalVelocity: JsonObject;
-    priority: JsonObject;
-    bEnabled: JsonObject;
-    reverbVolume: JsonObject;
-    fadeTime: JsonObject;
-    cullDistances: JsonObject;
-    bUnbound: JsonObject;
-    blendRadius: JsonObject;
-    blendWeight: JsonObject;
-    filter: JsonObject;
-    volumeType: JsonObject;
-    bBlockOnSlowStreaming: JsonObject;
-    boundsArray: JsonObject;
-    createIfMissing: JsonObject;
-    layerType: JsonObject;
-    nodeClass: JsonObject;
-    nodePosition: JsonObject;
-    nodeName: JsonObject;
-    sourceNodeName: JsonObject;
-    sourcePinName: JsonObject;
-    targetNodeName: JsonObject;
-    targetPinName: JsonObject;
-    save: JsonObject;
-    levelEditSave: JsonObject;
-    dimensions: JsonObject;
-    radius: JsonObject;
-    height: JsonObject;
-    boxHeight: JsonObject;
-    length: JsonObject;
-    baseRadius: JsonObject;
-    topRadius: JsonObject;
-    floating: JsonObject;
-    width: JsonObject;
-    depth: JsonObject;
-    scale: JsonObject;
-    thickness: JsonObject;
-    innerRadius: JsonObject;
-    outerRadius: JsonObject;
-    widthSegments: JsonObject;
-    heightSegments: JsonObject;
-    depthSegments: JsonObject;
-    radialSegments: JsonObject;
-    numSides: JsonObject;
-    numRings: JsonObject;
-    numSteps: JsonObject;
-    numTurns: JsonObject;
-    stepWidth: JsonObject;
-    stepHeight: JsonObject;
-    stepDepth: JsonObject;
-    segments: JsonObject;
-    amount: JsonObject;
-    distance: JsonObject;
-    angle: JsonObject;
-    position: JsonObject;
-    uvRotation: JsonObject;
-    outputPath: JsonObject;
-    lodCount: JsonObject;
-    lodIndex: JsonObject;
-    hullCount: JsonObject;
-    maxHullCount: JsonObject;
-    targetHullCount: JsonObject;
-    simplificationFactor: JsonObject;
-    reductionPercent: JsonObject;
-    trianglePercent: JsonObject;
-    recomputeNormals: JsonObject;
-    recomputeTangents: JsonObject;
-    screenSizes: JsonObject;
-    steps: JsonObject;
-    count: JsonObject;
-    iterations: JsonObject;
-    targetTriangleCount: JsonObject;
-    targetEdgeLength: JsonObject;
-    weldDistance: JsonObject;
-    uvChannel: JsonObject;
-    uvScale: JsonObject;
-    uvOffset: JsonObject;
-    hardEdgeAngle: JsonObject;
-    computeWeightedNormals: JsonObject;
-    collisionType: JsonObject;
-    strength: JsonObject;
-    frequency: JsonObject;
-    weight: JsonObject;
-    latticeResolution: JsonObject;
-    heightScale: JsonObject;
-    midpoint: JsonObject;
-    texturePath: JsonObject;
-    targetActor: JsonObject;
-    triangleIndices: JsonObject;
-    region: JsonObject;
-    edges: JsonObject;
-    numCuts: JsonObject;
-    toolActor: JsonObject;
-    trimActorName: JsonObject;
-    splineActorName: JsonObject;
-    keepTool: JsonObject;
-    keepInside: JsonObject;
-    cap: JsonObject;
-    axis: JsonObject;
-    center: JsonObject;
-    offset: JsonObject;
-    enableCollision: JsonObject;
-    vertexIndex: JsonObject;
-    triangleIndex: JsonObject;
-    groupID: JsonObject;
-    v0: JsonObject;
-    v1: JsonObject;
-    v2: JsonObject;
-    translation: JsonObject;
-    r: JsonObject;
-    g: JsonObject;
-    b: JsonObject;
-    a: JsonObject;
-    setAll: JsonObject;
-    u: JsonObject;
-    v: JsonObject;
-    splitAngle: JsonObject;
-    graphPath: JsonObject;
-    parentGraphPath: JsonObject;
-    subgraphPath: JsonObject;
-    assetPath: JsonObject;
-    path: JsonObject;
-    name: JsonObject;
-    nodeType: JsonObject;
-    settingsClass: JsonObject;
-    nodeId: JsonObject;
-    sourceNodeId: JsonObject;
-    targetNodeId: JsonObject;
-    sourcePin: JsonObject;
-    targetPin: JsonObject;
-    inputName: JsonObject;
-    outputName: JsonObject;
-    componentName: JsonObject;
-    componentPath: JsonObject;
-    createComponent: JsonObject;
-    force: JsonObject;
-    pcgScope: JsonObject;
-    pcgGridSize: JsonObject;
-    classPath: JsonObject;
-    actorClass: JsonObject;
-    meshPath: JsonObject;
-    overwrite: JsonObject;
-    posX: JsonObject;
-    posY: JsonObject;
-    x: JsonObject;
-    y: JsonObject;
-    title: JsonObject;
-    settings: JsonObject;
-};
-export type PropertyMap = JsonObject;
-//# sourceMappingURL=properties.d.ts.map

package/dist/tools/catalog/capabilities/records/world/properties.js

@@ -1,239 +0,0 @@
-import { str, num, bool } from '../shared/schema-props.js';
-const int = (d) => ({ type: 'integer', description: d });
-const arr = (d, item) => ({ type: 'array', items: item, description: d });
-const vec3 = (d) => ({
-    type: 'object', description: d,
-    properties: { x: num('X'), y: num('Y'), z: num('Z') },
-    additionalProperties: false,
-});
-const rot = (d) => ({
-    type: 'object', description: d,
-    properties: { pitch: num('Pitch'), yaw: num('Yaw'), roll: num('Roll') },
-    additionalProperties: false,
-});
-export const P = {
-    levelName: str('Level asset name.'),
-    levelPath: str('Canonical /Game level asset path.'),
-    parentLevel: str('Parent level asset path.'),
-    sublevelName: str('Sub-level asset name.'),
-    sublevelPath: str('Sub-level asset path.'),
-    bCreateWorldPartition: bool('Create with World Partition enabled.'),
-    bUseExternalActors: bool('Enable One File Per Actor (OFPA) for Data Layer compatibility.'),
-    streamingMethod: { type: 'string', enum: ['Blueprint', 'AlwaysLoaded'], description: 'Level streaming method: Blueprint (loaded on demand) or AlwaysLoaded.' },
-    bShouldBeVisible: bool('Level should be visible when loaded.'),
-    bShouldBlockOnLoad: bool('Block game until level is loaded.'),
-    bDisableDistanceStreaming: bool('Disable distance-based streaming.'),
-    streamingDistance: num('Distance/radius for streaming volume.'),
-    streamingUsage: str('Streaming volume usage mode.'),
-    createVolume: bool('Create a streaming volume (true) or report existing volumes (false).'),
-    bEnableWorldPartition: bool('Enable World Partition for level.'),
-    gridCellSize: num('World Partition grid cell size.'),
-    loadingRange: num('Loading range for grid cells.'),
-    gridName: str('World Partition runtime hash set grid name.'),
-    gridPriority: num('World Partition grid priority (higher wins when grids overlap).'),
-    dataLayerName: str('Data layer name.'),
-    bIsInitiallyVisible: bool('Data layer initially visible.'),
-    bIsInitiallyLoaded: bool('Data layer initially loaded.'),
-    dataLayerType: str('Type of data layer: Runtime or Editor.'),
-    actorName: str('Actor name in the level.'),
-    actorPath: str('Actor path in the level.'),
-    hlodLayerName: str('HLOD layer name.'),
-    hlodLayerPath: str('Canonical /Game HLOD layer asset path.'),
-    bIsSpatiallyLoaded: bool('HLOD is spatially loaded.'),
-    cellSize: num('HLOD cell size.'),
-    loadingDistance: num('HLOD loading distance.'),
-    volumeName: str('Volume actor name.'),
-    volumeLocation: vec3('Location of the volume.'),
-    volumeExtent: vec3('Extent of the volume.'),
-    location: vec3('World location {x, y, z}.'),
-    rotation: rot('Rotation {pitch, yaw, roll}.'),
-    extent: vec3('Extent (half-size) of the volume in each axis.'),
-    sphereRadius: num('Radius for sphere trigger volumes.'),
-    capsuleRadius: num('Radius for capsule trigger volumes.'),
-    capsuleHalfHeight: num('Half-height for capsule trigger volumes.'),
-    boxExtent: vec3('Extent for box trigger volumes.'),
-    bPainCausing: bool('Whether the volume causes pain/damage.'),
-    damagePerSec: num('Damage per second for pain volumes.'),
-    bWaterVolume: bool('Whether this is a water volume.'),
-    fluidFriction: num('Fluid friction for physics volumes.'),
-    terminalVelocity: num('Terminal velocity in the volume.'),
-    priority: num('Priority for audio volume.'),
-    bEnabled: bool('Whether the audio volume is enabled.'),
-    reverbVolume: num('Volume level for reverb (0.0-1.0).'),
-    fadeTime: num('Fade time for audio volume.'),
-    cullDistances: arr('Size/distance pairs for cull distance volumes.', {
-        type: 'object',
-        properties: { size: num('Object size threshold.'), cullDistance: num('Distance at which to cull.') },
-        additionalProperties: false,
-    }),
-    bUnbound: bool('Whether post process volume affects entire world.'),
-    blendRadius: num('Blend radius for post process volume.'),
-    blendWeight: num('Blend weight (0.0-1.0) for post process.'),
-    filter: str('Only volumes whose label contains this text, ignoring case (e.g. "Kill", "Water"). For a kind of volume use volumeType.'),
-    volumeType: str('Only volumes whose class name contains this, ignoring case (e.g. "PostProcess", "Physics", "Blocking"); "Trigger" also returns the trigger actors (TriggerBox, TriggerSphere).'),
-    bBlockOnSlowStreaming: bool('Block on slow streaming.'),
-    boundsArray: {
-        type: 'array',
-        description: 'Volume bounds as a six-number array [minX, minY, minZ, maxX, maxY, maxZ].',
-        items: { type: 'number' },
-        minItems: 6,
-        maxItems: 6,
-    },
-    createIfMissing: bool('Create the grid if missing.'),
-    layerType: str('Layer type for runtime hash set grid.'),
-    nodeClass: str('Level blueprint graph node class.'),
-    nodePosition: { type: 'object', description: 'Node graph position {x, y}.', properties: { x: num('X'), y: num('Y') }, additionalProperties: false },
-    nodeName: str('Level blueprint node name.'),
-    sourceNodeName: str('Source node name for connection.'),
-    sourcePinName: str('Source pin name.'),
-    targetNodeName: str('Target node name for connection.'),
-    targetPinName: str('Target pin name.'),
-    save: bool('Whether to save the level after the operation.'),
-    levelEditSave: bool('Save the level after the edit (default false, because saving also writes every other unsaved change in that level); the reply says saved: false while it is only in memory.'),
-    dimensions: vec3('Primitive dimensions {x, y, z}.'),
-    radius: num('Primitive radius.'),
-    height: num('Primitive height along the primary axis (cylinder, cone, pipe, ramp).'),
-    boxHeight: num('Box Y dimension: the box is X=width, Y=height, Z=depth (dimensions.{x,y,z}).'),
-    length: num('Length along the primary axis: the capsule shaft, or the ramp run.'),
-    baseRadius: num('Cone base radius; defaults to radius.'),
-    topRadius: num('Cone top radius; non-zero makes a truncated cone. Defaults to 0.'),
-    floating: bool('Build the stairs as free-floating steps with no solid underside.'),
-    width: num('Primitive width along X.'),
-    depth: num('Primitive depth: a box\'s size along Z; a plane\'s size along Y (a plane lies flat in XY, centred, facing +Z).'),
-    scale: vec3('Spawn scale {x, y, z}.'),
-    thickness: num('Shell wall thickness (scalar).'),
-    innerRadius: num('Inner radius (torus minor radius, ring/pipe inner wall).'),
-    outerRadius: num('Outer radius for ring and pipe primitives.'),
-    widthSegments: int('Tessellation segments along width.'),
-    heightSegments: int('Tessellation segments along height (on a plane, along its depth, Y).'),
-    depthSegments: int('Tessellation segments along depth.'),
-    radialSegments: int('Radial tessellation segments for circular primitives.'),
-    numSides: int('Number of sides for cylinder, cone, disc, ring, torus.'),
-    numRings: int('Number of rings for sphere, capsule, torus, arch.'),
-    numSteps: int('Number of steps for stair primitives.'),
-    numTurns: num('Number of turns for spiral stairs (converted to a curve angle).'),
-    stepWidth: num('Width of each stair step.'),
-    stepHeight: num('Height of each stair step.'),
-    stepDepth: num('Depth of each stair step.'),
-    segments: int('Number of segments for the operation.'),
-    amount: num('Generic amount (bevel size, inset/extrude distance).'),
-    distance: num('Distance for offset-style operations.'),
-    angle: num('Angle in degrees.'),
-    position: vec3('Position {x, y, z} for the operation.'),
-    uvRotation: num('UV rotation in degrees (transform_uvs takes a scalar, not a rotator).'),
-    outputPath: str('Canonical /Game output asset path.'),
-    lodCount: int('Number of LOD levels to generate.'),
-    lodIndex: int('Specific LOD index to configure.'),
-    hullCount: int('Number of convex hulls for decomposition.'),
-    maxHullCount: int('Maximum hull count for complex collision generation.'),
-    targetHullCount: int('Target hull count for collision simplification.'),
-    simplificationFactor: num('Collision simplification factor.'),
-    reductionPercent: num('Percent of triangles to reduce.'),
-    trianglePercent: num('Percent of triangles to keep for LOD reduction.'),
-    recomputeNormals: bool('Recompute normals for the LOD.'),
-    recomputeTangents: bool('Recompute tangents for the LOD.'),
-    screenSizes: arr('Screen size for each LOD.', num('Screen size.')),
-    steps: int('Number of steps.'),
-    count: int('Count of repeated elements.'),
-    iterations: int('Number of iterations for smooth/remesh.'),
-    targetTriangleCount: num('Target triangle count for simplification.'),
-    targetEdgeLength: num('Target edge length for remeshing.'),
-    weldDistance: num('Distance threshold for vertex welding.'),
-    uvChannel: int('UV channel index (0-7).'),
-    uvScale: { type: 'object', description: 'UV scale {u, v}.', properties: { u: num('U'), v: num('V') }, additionalProperties: false },
-    uvOffset: { type: 'object', description: 'UV offset {u, v}.', properties: { u: num('U'), v: num('V') }, additionalProperties: false },
-    hardEdgeAngle: num('Angle threshold for hard edges (degrees).'),
-    computeWeightedNormals: bool('Use area-weighted normals.'),
-    collisionType: str('Collision complexity type.'),
-    strength: num('Deformation strength: bend/twist angle in degrees, taper flare percent, noise displacement in units, stretch factor, spherify/cylindrify blend 0-1.'),
-    frequency: num('Noise frequency in cycles per unit; defaults to three bumps across the mesh\'s largest dimension.'),
-    weight: num('Weight for lattice deformation.'),
-    latticeResolution: int('Control lattice resolution for lattice deformation.'),
-    heightScale: num('Texture displacement height scale.'),
-    midpoint: num('Texture luminance midpoint for displacement.'),
-    texturePath: str('Canonical /Game texture asset path.'),
-    targetActor: str('Target actor name for boolean operations.'),
-    triangleIndices: arr('Triangle ids the operation is limited to; omit to apply it to the whole mesh. Give this or region, not both.', { type: 'integer' }),
-    region: {
-        type: 'object',
-        description: 'Pick the triangles to work on by where they are or what they carry, instead of by id; give this or triangleIndices, not both. Every filter given must hold, so they AND together. '
-            + 'Boxes and directions are in the mesh\'s local space, not world space. A region that matches nothing is refused (REGION_EMPTY) with the mesh\'s local bounds in the message, '
-            + 'and the reply\'s trianglesSelected says how many triangles were picked.',
-        properties: {
-            box: {
-                type: 'object',
-                description: 'Triangles whose centroid lies inside this box (inclusive), in the mesh\'s local space.',
-                properties: { min: vec3('Corner with the smallest x, y and z.'), max: vec3('Corner with the largest x, y and z.') },
-                required: ['min', 'max'],
-                additionalProperties: false,
-            },
-            normal: vec3('Direction {x, y, z} in the mesh\'s local space; picks the triangles that face it, within normalAngle. {x: 0, y: 0, z: 1} is the top faces.'),
-            normalAngle: num('Degrees either side of normal that still count as facing it (default 30).'),
-            groupIds: arr('Triangles that belong to one of these polygroup ids; a mesh without polygroups is all group 0.', { type: 'integer' }),
-            materialIds: arr('Triangles that carry one of these material ids (a mesh without material ids is all 0).', { type: 'integer' }),
-        },
-        additionalProperties: false,
-    },
-    edges: arr('Edge ids to split at their midpoints.', { type: 'integer' }),
-    numCuts: int('Number of evenly spaced cuts.'),
-    toolActor: str('Tool actor name for boolean operations.'),
-    trimActorName: str('Trim actor name for boolean trim.'),
-    splineActorName: str('Spline actor name for extrude/sweep along spline.'),
-    keepTool: bool('Keep the tool actor after the operation.'),
-    keepInside: bool('Keep geometry inside the tool.'),
-    cap: bool('Cap open ends of tubes.'),
-    axis: str('Axis: X, Y, or Z.'),
-    center: vec3('Center of operation.'),
-    offset: vec3('Offset vector.'),
-    enableCollision: bool('Enable simple collision on the created DynamicMesh actor.'),
-    vertexIndex: int('Index of the vertex the operation targets.'),
-    triangleIndex: int('Index of the triangle the operation targets.'),
-    groupID: int('Polygroup id assigned to the appended triangle.'),
-    v0: vec3('First corner {x, y, z} of the appended triangle.'),
-    v1: vec3('Second corner {x, y, z} of the appended triangle.'),
-    v2: vec3('Third corner {x, y, z} of the appended triangle.'),
-    translation: vec3('Translation {x, y, z} applied to every mesh vertex.'),
-    r: num('Red channel, 0-1.'),
-    g: num('Green channel, 0-1.'),
-    b: num('Blue channel, 0-1.'),
-    a: num('Alpha channel, 0-1.'),
-    setAll: bool('Apply the colour to every vertex instead of one.'),
-    u: num('U coordinate.'),
-    v: num('V coordinate.'),
-    splitAngle: num('Angle threshold in degrees above which normals are split.'),
-    graphPath: str('PCG graph asset path (e.g. /Game/PCG/PCG_MyGraph).'),
-    parentGraphPath: str('Parent PCG graph asset path for subgraph insertion.'),
-    subgraphPath: str('PCG subgraph asset path used by subgraph nodes.'),
-    assetPath: str('Canonical /Game asset path.'),
-    path: str('Canonical /Game directory path.'),
-    name: str('Name for the new asset or node.'),
-    nodeType: str('PCG node type alias or UPCGSettings class path/name.'),
-    settingsClass: str('UPCGSettings class path/name for the PCG node.'),
-    nodeId: str('PCG node identifier.'),
-    sourceNodeId: str('Source node identifier for pin connection.'),
-    targetNodeId: str('Target node identifier for pin connection.'),
-    sourcePin: str('Source pin name.'),
-    targetPin: str('Target pin name.'),
-    inputName: str('PCG input pin name.'),
-    outputName: str('PCG output pin name.'),
-    componentName: str('Component name for PCG execution.'),
-    componentPath: str('Component path/name for PCG execution.'),
-    createComponent: bool('Create a new PCG component when no selector is supplied.'),
-    force: bool('Force regeneration even if a result already exists.'),
-    pcgScope: str("Partition grid target scope: 'world' or 'component'."),
-    pcgGridSize: num('PCG partition grid cell size.'),
-    classPath: str('Class path/name.'),
-    actorClass: str('Actor class path/name.'),
-    meshPath: str('Canonical /Game static mesh asset path.'),
-    overwrite: bool('Overwrite the asset when it already exists.'),
-    posX: num('Node graph X position.'),
-    posY: num('Node graph Y position.'),
-    x: num('Node graph X position (alias of posX).'),
-    y: num('Node graph Y position (alias of posY).'),
-    title: str('Node title (alias of nodeName).'),
-    settings: {
-        type: 'object', description: 'UPCGSettings property key-value pairs applied by reflection.',
-        additionalProperties: true, 'x-unreal-reflection-boundary': true,
-    },
-};
-//# sourceMappingURL=properties.js.map

package/dist/tools/catalog/capabilities/retrieval/alias-fold.d.ts

@@ -1,7 +0,0 @@
-import type { CapabilityRecord } from '../model.js';
-export type AliasFold = {
-    readonly targets: ReadonlyMap<string, string>;
-};
-export declare function deriveAliasFold(records: readonly CapabilityRecord[]): AliasFold;
-export declare function canonicalCapabilityId(fold: AliasFold, id: string): string;
-//# sourceMappingURL=alias-fold.d.ts.map

package/dist/tools/catalog/capabilities/retrieval/alias-fold.js

@@ -1,20 +0,0 @@
-export function deriveAliasFold(records) {
-    const known = new Set(records.map((record) => String(record.id)));
-    const targets = new Map();
-    for (const record of records) {
-        const namespace = String(record.id).split('.').slice(0, -1).join('.');
-        for (const legacy of record.legacyIds) {
-            if (legacy.folded === undefined)
-                continue;
-            const former = namespace.length === 0 ? String(legacy.action) : `${namespace}.${String(legacy.action)}`;
-            if (!known.has(former) && record.aliases.some((alias) => String(alias) === former)) {
-                targets.set(former, String(record.id));
-            }
-        }
-    }
-    return Object.freeze({ targets });
-}
-export function canonicalCapabilityId(fold, id) {
-    return fold.targets.get(id) ?? id;
-}
-//# sourceMappingURL=alias-fold.js.map

package/dist/tools/catalog/capabilities/retrieval/constants.d.ts

@@ -1,56 +0,0 @@
-import type { CapabilityMatchField } from './scoring.js';
-export declare const RETRIEVAL_TOKENIZATION: Readonly<{
-    readonly locale: "invariant";
-    readonly caseFold: "lowercase";
-    readonly tokenPattern: "[a-z0-9]+";
-    readonly splitCamelCase: true;
-    readonly foldInflections: true;
-    readonly maxQueryLength: 512;
-    readonly maxTokens: 48;
-    readonly maxTokenLength: 64;
-}>;
-export declare const RETRIEVAL_NAME_FIELDS: ReadonlySet<CapabilityMatchField>;
-export declare const RETRIEVAL_COVERAGE_FIELDS: ReadonlySet<CapabilityMatchField>;
-export declare const RETRIEVAL_FIELD_WEIGHTS: Readonly<{
-    canonical_id: number;
-    alias: number;
-    legacy_tool: number;
-    legacy_action: number;
-    domain: number;
-    family: number;
-    topic: number;
-    summary: number;
-    when_to_use: number;
-    when_not_to_use: number;
-}>;
-export declare const RETRIEVAL_FUNCTION_WORDS: ReadonlySet<string>;
-export declare const RETRIEVAL_READ_INTENT_WORDS: ReadonlySet<string>;
-export declare const RETRIEVAL_DELETE_INTENT_WORDS: ReadonlySet<string>;
-export declare const SCORE_TIE_EPSILON: 1e-9;
-export declare const MAX_MATCH_REASONS: 3;
-export declare const MAX_REASON_TOKENS: 3;
-export declare const RETRIEVAL_SCORE_CONSTANTS: Readonly<{
-    readonly bm25K1: 1.2;
-    readonly bm25LengthNormalization: 0.75;
-    readonly exactCanonicalIdBonus: 60;
-    readonly exactAliasBonus: 55;
-    readonly exactLegacyPairBonus: 50;
-    readonly exactLegacyActionBonus: 30;
-    readonly matchedActionTokenBonus: 8;
-    readonly adjacentQueryPairBonus: 8;
-    readonly unmatchedActionTokenPenalty: 20;
-    readonly functionWordWeight: 0.25;
-    readonly headVerbAlignmentBonus: 6;
-    readonly headVerbMismatchPenalty: 10;
-    readonly readIntentBonus: 80;
-    readonly deleteIntentBonus: 14;
-    readonly fullCoverageBonus: 100;
-    readonly minimumRelevanceScore: 0.01;
-    readonly confidenceSaturation: 40;
-    readonly confidenceSaturationWeight: 0.85;
-    readonly confidenceCoverageWeight: 0.15;
-    readonly minimumAutoSelectConfidence: 0.35;
-    readonly scorePrecision: 6;
-    readonly confidencePrecision: 4;
-}>;
-//# sourceMappingURL=constants.d.ts.map

package/dist/tools/catalog/capabilities/retrieval/constants.js

@@ -1,71 +0,0 @@
-export const RETRIEVAL_TOKENIZATION = Object.freeze({
-    locale: 'invariant',
-    caseFold: 'lowercase',
-    tokenPattern: '[a-z0-9]+',
-    splitCamelCase: true,
-    foldInflections: true,
-    maxQueryLength: 512,
-    maxTokens: 48,
-    maxTokenLength: 64,
-});
-export const RETRIEVAL_NAME_FIELDS = new Set([
-    'canonical_id', 'alias', 'legacy_tool', 'legacy_action',
-]);
-export const RETRIEVAL_COVERAGE_FIELDS = new Set([
-    'legacy_action', 'domain', 'family', 'topic',
-]);
-export const RETRIEVAL_FIELD_WEIGHTS = Object.freeze({
-    canonical_id: 6,
-    alias: 7,
-    legacy_tool: 2,
-    legacy_action: 10,
-    domain: 2,
-    family: 4,
-    topic: 8,
-    summary: 3,
-    when_to_use: 2,
-    when_not_to_use: 0.25,
-});
-export const RETRIEVAL_FUNCTION_WORDS = Object.freeze(new Set([
-    'a', 'an', 'the', 'this', 'that', 'these', 'those', 'of', 'in', 'on', 'at',
-    'to', 'for', 'from', 'by', 'with', 'into', 'onto', 'and', 'or', 'but', 'it',
-    'its', 'is', 'are', 'be', 'as', 'all', 'every', 'any', 'some', 'my', 'our',
-    'their', 'his', 'her', 'you', 'me', 'we', 'i', 'please', 'then', 'so',
-    'what', 'which', 'how', 'where', 'who', 'when', 'why', 'do', 'does', 'did',
-    'can', 'could', 'should', 'would', 'will', 'want', 'need',
-]));
-export const RETRIEVAL_READ_INTENT_WORDS = Object.freeze(new Set([
-    'get', 'read', 'list', 'inspect', 'query', 'describe', 'find', 'count', 'show',
-    'what', 'which', 'where', 'who', 'how', 'is', 'does',
-]));
-export const RETRIEVAL_DELETE_INTENT_WORDS = Object.freeze(new Set([
-    'delete', 'remove', 'destroy', 'erase',
-]));
-export const SCORE_TIE_EPSILON = 1e-9;
-export const MAX_MATCH_REASONS = 3;
-export const MAX_REASON_TOKENS = 3;
-export const RETRIEVAL_SCORE_CONSTANTS = Object.freeze({
-    bm25K1: 1.2,
-    bm25LengthNormalization: 0.75,
-    exactCanonicalIdBonus: 60,
-    exactAliasBonus: 55,
-    exactLegacyPairBonus: 50,
-    exactLegacyActionBonus: 30,
-    matchedActionTokenBonus: 8,
-    adjacentQueryPairBonus: 8,
-    unmatchedActionTokenPenalty: 20,
-    functionWordWeight: 0.25,
-    headVerbAlignmentBonus: 6,
-    headVerbMismatchPenalty: 10,
-    readIntentBonus: 80,
-    deleteIntentBonus: 14,
-    fullCoverageBonus: 100,
-    minimumRelevanceScore: 0.01,
-    confidenceSaturation: 40,
-    confidenceSaturationWeight: 0.85,
-    confidenceCoverageWeight: 0.15,
-    minimumAutoSelectConfidence: 0.35,
-    scorePrecision: 6,
-    confidencePrecision: 4,
-});
-//# sourceMappingURL=constants.js.map

package/dist/tools/catalog/capabilities/retrieval/scoring.d.ts

@@ -1,52 +0,0 @@
-import type { CapabilityRecord } from '../model.js';
-import { type AliasFold } from './alias-fold.js';
-export type CapabilityMatchField = 'canonical_id' | 'alias' | 'legacy_tool' | 'legacy_action' | 'domain' | 'family' | 'topic' | 'summary' | 'when_to_use' | 'when_not_to_use';
-export type CapabilityMatchReason = {
-    readonly field: CapabilityMatchField;
-    readonly matchedTokens: readonly string[];
-};
-export type IndexedField = {
-    readonly field: CapabilityMatchField;
-    readonly tokens: readonly string[];
-    readonly counts: ReadonlyMap<string, number>;
-};
-export type IndexedCapability = {
-    readonly record: CapabilityRecord;
-    readonly fields: readonly IndexedField[];
-    readonly scoredFields: readonly IndexedField[];
-    readonly sequences: readonly (readonly string[])[];
-    readonly idTokens: readonly string[];
-    readonly aliasTokens: readonly (readonly string[])[];
-    readonly aliasActionTokens: readonly (readonly string[])[];
-    readonly legacyPairTokens: readonly (readonly string[])[];
-    readonly legacyActionTokens: readonly (readonly string[])[];
-    readonly actionTokenSets: readonly (readonly string[])[];
-};
-export type CapabilitySearchIndex = {
-    readonly documents: readonly IndexedCapability[];
-    readonly documentFrequency: ReadonlyMap<string, number>;
-    readonly averageFieldLengths: ReadonlyMap<CapabilityMatchField, number>;
-    readonly aliasFold: AliasFold;
-};
-export type RankedCapability = {
-    readonly record: CapabilityRecord;
-    readonly score: number;
-    readonly confidence: number;
-    readonly reasons: readonly CapabilityMatchReason[];
-};
-export type FieldContribution = CapabilityMatchReason & {
-    readonly score: number;
-    readonly allMatchedTokens: readonly string[];
-};
-export type ScoreContext = {
-    readonly index: CapabilitySearchIndex;
-    readonly queryTokens: readonly string[];
-    readonly contentTokens: readonly string[];
-    readonly querySet: ReadonlySet<string>;
-    readonly readIntent: boolean;
-    readonly deleteIntent: boolean;
-};
-export declare function createCapabilitySearchIndex(records: readonly CapabilityRecord[]): CapabilitySearchIndex;
-export declare function scoreDocument(document: IndexedCapability, context: ScoreContext): RankedCapability | null;
-export declare function rankCapabilityRecords(index: CapabilitySearchIndex, records: readonly CapabilityRecord[], query: string): readonly RankedCapability[];
-//# sourceMappingURL=scoring.d.ts.map