@digital-finance-ui/ui-kit-mcp 0.2.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +43 -0
- package/data/component-index.json +57735 -0
- package/dist/resolveIndex.js +145 -0
- package/dist/server.js +113 -0
- package/dist/tools/getComponent.js +98 -0
- package/dist/tools/getComponentExamples.js +27 -0
- package/dist/tools/getComponentProps.js +59 -0
- package/dist/tools/getFeature.js +18 -0
- package/dist/tools/getFeatureExamples.js +26 -0
- package/dist/tools/getInstallationGuide.js +7 -0
- package/dist/tools/getType.js +136 -0
- package/dist/tools/listCategories.js +18 -0
- package/dist/tools/listComponents.js +50 -0
- package/dist/tools/listFeatures.js +16 -0
- package/dist/tools/searchComponents.js +259 -0
- package/dist/tools/shared.js +38 -0
- package/dist/tools/truncate.js +80 -0
- package/dist/types.js +8 -0
- package/package.json +25 -0
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import { isOkComponent } from '../types.js';
|
|
2
|
+
export function listCategories(index) {
|
|
3
|
+
const byCategory = new Map();
|
|
4
|
+
Object.values(index.components)
|
|
5
|
+
.filter(isOkComponent)
|
|
6
|
+
.forEach((c) => {
|
|
7
|
+
const key = c.category || '(без категории)';
|
|
8
|
+
const entry = byCategory.get(key) || {
|
|
9
|
+
category: key,
|
|
10
|
+
count: 0,
|
|
11
|
+
types: {},
|
|
12
|
+
};
|
|
13
|
+
entry.count += 1;
|
|
14
|
+
entry.types[c.type] = (entry.types[c.type] || 0) + 1;
|
|
15
|
+
byCategory.set(key, entry);
|
|
16
|
+
});
|
|
17
|
+
return { categories: Array.from(byCategory.values()) };
|
|
18
|
+
}
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
import { isOkComponent } from '../types.js';
|
|
2
|
+
import { RESPONSE_BUDGET_CHARS, truncateList } from './truncate.js';
|
|
3
|
+
const DESCRIPTION_CLIP_CHARS = 120;
|
|
4
|
+
function clipDescription(description) {
|
|
5
|
+
if (!description)
|
|
6
|
+
return undefined;
|
|
7
|
+
if (description.length <= DESCRIPTION_CLIP_CHARS)
|
|
8
|
+
return description;
|
|
9
|
+
return `${description.slice(0, DESCRIPTION_CLIP_CHARS - 1)}…`;
|
|
10
|
+
}
|
|
11
|
+
export function listComponents(index, { type, category, scope, role, limit, offset } = {}) {
|
|
12
|
+
const roleFilter = role ?? 'primary';
|
|
13
|
+
const filtered = Object.values(index.components)
|
|
14
|
+
.filter(isOkComponent)
|
|
15
|
+
.filter((c) => !type || c.type === type)
|
|
16
|
+
.filter((c) => !category || c.category === category)
|
|
17
|
+
.filter((c) => !scope || c.scope === scope)
|
|
18
|
+
.filter((c) => roleFilter === 'all' || c.role === roleFilter)
|
|
19
|
+
.map((c) => ({
|
|
20
|
+
name: c.name,
|
|
21
|
+
type: c.type,
|
|
22
|
+
category: c.category,
|
|
23
|
+
description: clipDescription(c.description),
|
|
24
|
+
// legacy и deprecated сигналят одно и то же ("не используйте это") —
|
|
25
|
+
// не показываем оба сразу, deprecated значим только сам по себе.
|
|
26
|
+
legacy: c.legacy || undefined,
|
|
27
|
+
deprecated: !c.legacy && c.deprecated ? true : undefined,
|
|
28
|
+
hasFormVariant: c.formVariant ? true : undefined,
|
|
29
|
+
role: c.role !== 'primary' ? c.role : undefined,
|
|
30
|
+
parentComponent: c.role !== 'primary' ? c.parentComponent : undefined,
|
|
31
|
+
}));
|
|
32
|
+
const total = filtered.length;
|
|
33
|
+
if (limit !== undefined || offset !== undefined) {
|
|
34
|
+
const start = offset ?? 0;
|
|
35
|
+
const end = limit !== undefined ? start + limit : filtered.length;
|
|
36
|
+
const page = filtered.slice(start, end);
|
|
37
|
+
const hasMore = end < total;
|
|
38
|
+
return {
|
|
39
|
+
items: page,
|
|
40
|
+
shown: page.length,
|
|
41
|
+
total,
|
|
42
|
+
hasMore,
|
|
43
|
+
truncationNotice: hasMore
|
|
44
|
+
? `Показано ${page.length} из ${total}. Следующая страница: offset=${end}.`
|
|
45
|
+
: undefined,
|
|
46
|
+
};
|
|
47
|
+
}
|
|
48
|
+
const result = truncateList(filtered, RESPONSE_BUDGET_CHARS);
|
|
49
|
+
return { ...result, hasMore: result.shown < result.total || undefined };
|
|
50
|
+
}
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
import { listComponentFeatures } from './shared.js';
|
|
2
|
+
export function listFeatures(index, { component } = {}) {
|
|
3
|
+
if (!component) {
|
|
4
|
+
return { error: 'Параметр component обязателен.' };
|
|
5
|
+
}
|
|
6
|
+
const features = listComponentFeatures(index, component);
|
|
7
|
+
return {
|
|
8
|
+
component,
|
|
9
|
+
count: features.length,
|
|
10
|
+
features: features.map((f) => ({
|
|
11
|
+
feature: f.feature,
|
|
12
|
+
summary: f.summary,
|
|
13
|
+
legacy: f.legacy || undefined,
|
|
14
|
+
})),
|
|
15
|
+
};
|
|
16
|
+
}
|
|
@@ -0,0 +1,259 @@
|
|
|
1
|
+
import { isOkComponent } from '../types.js';
|
|
2
|
+
const LEGACY_PENALTY_FACTOR = 0.6;
|
|
3
|
+
/**
|
|
4
|
+
* По роли (см. classifyRole.ts) НЕ фильтруем — агент может целенаправленно
|
|
5
|
+
* искать именно "ModalDFHeader" или служебный примитив. Но 'internal'
|
|
6
|
+
* (CanvasRect и подобные — в прикладном коде не встречаются никогда)
|
|
7
|
+
* понижаем тем же приёмом, что и legacy: множительный штраф, а не
|
|
8
|
+
* исключение, иначе единственное точное совпадение по имени пропадёт из
|
|
9
|
+
* выдачи.
|
|
10
|
+
*/
|
|
11
|
+
const INTERNAL_PENALTY_FACTOR = 0.6;
|
|
12
|
+
// Короткие предлоги/союзы — как токены почти ничего не значат, но как
|
|
13
|
+
// подстрока встречаются почти везде ("в" входит в половину слов) и без
|
|
14
|
+
// фильтра забивают релевантный скоринг шумом.
|
|
15
|
+
const STOPWORDS = new Set([
|
|
16
|
+
'в',
|
|
17
|
+
'с',
|
|
18
|
+
'к',
|
|
19
|
+
'на',
|
|
20
|
+
'из',
|
|
21
|
+
'от',
|
|
22
|
+
'до',
|
|
23
|
+
'по',
|
|
24
|
+
'и',
|
|
25
|
+
'а',
|
|
26
|
+
'но',
|
|
27
|
+
'как',
|
|
28
|
+
'для',
|
|
29
|
+
'это',
|
|
30
|
+
'the',
|
|
31
|
+
'a',
|
|
32
|
+
'an',
|
|
33
|
+
'in',
|
|
34
|
+
'on',
|
|
35
|
+
'of',
|
|
36
|
+
'to',
|
|
37
|
+
]);
|
|
38
|
+
/** Первая содержательная строка определения — узнать тип, не заказывая его целиком. */
|
|
39
|
+
function firstLine(definition) {
|
|
40
|
+
const line = definition.split('\n').find((l) => l.trim().length > 0) || '';
|
|
41
|
+
return line.trim().slice(0, 120);
|
|
42
|
+
}
|
|
43
|
+
/**
|
|
44
|
+
* Морфологии здесь намеренно нет. Пробовал дешёвый стемминг (отрезать
|
|
45
|
+
* падежное окончание и засчитывать совпадение по основе с меньшим весом) —
|
|
46
|
+
* замер на 12 запросах дал ровно тот же результат, 8 попаданий в топ-3, что
|
|
47
|
+
* и без него, но заметно прибавил шума: на "конфигурация группировки колонок"
|
|
48
|
+
* фичи таблицы вытеснялись `Container`/`Layout`/`Col`, поймавшими основу
|
|
49
|
+
* "колон" в общих доках. Русские словоформы стоит закрывать нормальным
|
|
50
|
+
* стеммером, а не эвристикой на два символа.
|
|
51
|
+
*/
|
|
52
|
+
function tokenize(query) {
|
|
53
|
+
return (query || '')
|
|
54
|
+
.toLowerCase()
|
|
55
|
+
.split(/[\s,.;:!?()[\]{}'"«»]+/)
|
|
56
|
+
.filter((w) => w.length > 0 && !STOPWORDS.has(w));
|
|
57
|
+
}
|
|
58
|
+
/**
|
|
59
|
+
* Курированные hint/description иногда пишутся как явное опровержение
|
|
60
|
+
* ("Это layout, не фильтрация" у AnalyticalWidget) — специально предупреждают,
|
|
61
|
+
* что компонент НЕ об этом. Наивное совпадение подстроки засчитало бы это как
|
|
62
|
+
* позитивный сигнал ровно наоборот. Проверяем, не стоит ли перед совпадением
|
|
63
|
+
* "не " — если да, не начисляем очки за это вхождение.
|
|
64
|
+
*/
|
|
65
|
+
function includesPositively(text, word) {
|
|
66
|
+
const idx = text.indexOf(word);
|
|
67
|
+
if (idx === -1)
|
|
68
|
+
return false;
|
|
69
|
+
const before = text.slice(Math.max(0, idx - 4), idx);
|
|
70
|
+
return !/не\s*$/.test(before);
|
|
71
|
+
}
|
|
72
|
+
function scoreComponent(component, tokens) {
|
|
73
|
+
const name = component.name.toLowerCase();
|
|
74
|
+
const hint = (component.hint || '').toLowerCase();
|
|
75
|
+
const description = (component.description || '').toLowerCase();
|
|
76
|
+
const keywords = (component.keywords || []).join(' ').toLowerCase();
|
|
77
|
+
const docs = (component.docs || '').toLowerCase();
|
|
78
|
+
const category = (component.category || '').toLowerCase();
|
|
79
|
+
let score = 0;
|
|
80
|
+
tokens.forEach((w) => {
|
|
81
|
+
if (name === w)
|
|
82
|
+
score += 100;
|
|
83
|
+
else if (name.includes(w))
|
|
84
|
+
score += 15;
|
|
85
|
+
if (includesPositively(hint, w))
|
|
86
|
+
score += 20;
|
|
87
|
+
if (includesPositively(keywords, w))
|
|
88
|
+
score += 20;
|
|
89
|
+
if (includesPositively(description, w))
|
|
90
|
+
score += 10;
|
|
91
|
+
if (docs.includes(w))
|
|
92
|
+
score += 4;
|
|
93
|
+
if (category.includes(w))
|
|
94
|
+
score += 2;
|
|
95
|
+
});
|
|
96
|
+
// Мультипликативный штраф, а не вычитание — иначе единственное совпадение
|
|
97
|
+
// по редкому термину (например "react-data-grid" только у Table) целиком
|
|
98
|
+
// гасится штрафом до нуля и компонент пропадает из выдачи, хотя это ровно
|
|
99
|
+
// тот случай, где он единственно верный ответ.
|
|
100
|
+
if (component.legacy && score > 0)
|
|
101
|
+
score *= LEGACY_PENALTY_FACTOR;
|
|
102
|
+
if (component.role === 'internal' && score > 0)
|
|
103
|
+
score *= INTERNAL_PENALTY_FACTOR;
|
|
104
|
+
return score;
|
|
105
|
+
}
|
|
106
|
+
function scoreFeature(feature, tokens) {
|
|
107
|
+
const featureName = feature.feature.toLowerCase();
|
|
108
|
+
const componentName = feature.component.toLowerCase();
|
|
109
|
+
const summary = (feature.summary || '').toLowerCase();
|
|
110
|
+
const docs = (feature.docs || '').toLowerCase();
|
|
111
|
+
const apiDocs = (feature.apiDocs || '').toLowerCase();
|
|
112
|
+
let score = 0;
|
|
113
|
+
tokens.forEach((w) => {
|
|
114
|
+
if (featureName === w)
|
|
115
|
+
score += 80;
|
|
116
|
+
else if (featureName.includes(w))
|
|
117
|
+
score += 15;
|
|
118
|
+
if (componentName.includes(w))
|
|
119
|
+
score += 10;
|
|
120
|
+
if (summary.includes(w))
|
|
121
|
+
score += 10;
|
|
122
|
+
if (docs.includes(w))
|
|
123
|
+
score += 4;
|
|
124
|
+
if (apiDocs.includes(w))
|
|
125
|
+
score += 3;
|
|
126
|
+
});
|
|
127
|
+
if (feature.legacy && score > 0)
|
|
128
|
+
score *= LEGACY_PENALTY_FACTOR;
|
|
129
|
+
return score;
|
|
130
|
+
}
|
|
131
|
+
/**
|
|
132
|
+
* Тип ищется и по имени, и по ТЕКСТУ определения — это единственный способ
|
|
133
|
+
* ответить на запросы вида "как отрисовать свою ячейку" или "GridCellKind
|
|
134
|
+
* renderCell": нужное имя (`CellContent`) агент заранее не знает, а в тексте
|
|
135
|
+
* `ColumnConfig` оно написано. Вес по определению маленький: определения
|
|
136
|
+
* длинные (до 6000 символов), и по совпадению одного слова тип не должен
|
|
137
|
+
* обгонять компонент, у которого это слово в имени.
|
|
138
|
+
*
|
|
139
|
+
* Внутренние типы (не экспортированы наружу) понижаются тем же приёмом, что
|
|
140
|
+
* legacy и internal-роль: они полезны для понимания структуры, но ответом на
|
|
141
|
+
* "что импортировать" быть не могут.
|
|
142
|
+
*/
|
|
143
|
+
function scoreType(record, tokens) {
|
|
144
|
+
const name = record.name.toLowerCase();
|
|
145
|
+
const definition = record.definition.toLowerCase();
|
|
146
|
+
let score = 0;
|
|
147
|
+
tokens.forEach((w) => {
|
|
148
|
+
if (name === w)
|
|
149
|
+
score += 90;
|
|
150
|
+
else if (name.includes(w))
|
|
151
|
+
score += 15;
|
|
152
|
+
if (definition.includes(w))
|
|
153
|
+
score += 3;
|
|
154
|
+
});
|
|
155
|
+
if (record.internal && score > 0)
|
|
156
|
+
score *= INTERNAL_PENALTY_FACTOR;
|
|
157
|
+
return score;
|
|
158
|
+
}
|
|
159
|
+
/**
|
|
160
|
+
* Порог отсечки шума: в реальном логе запрос "GridCellKind renderCell ячейка
|
|
161
|
+
* текст CellContent" вернул TableCanvas со 100 очками и следом пять
|
|
162
|
+
* компонентов с 6-30 очками, не имевших к вопросу никакого отношения
|
|
163
|
+
* (`Counter`, `ToastProvider`, `TextSkeleton` — совпало одно общее слово в
|
|
164
|
+
* описании). Отсекаем хвост относительно лучшего результата, а не абсолютным
|
|
165
|
+
* значением: у редких терминов абсолютные очки низкие у ВСЕХ хитов, и
|
|
166
|
+
* фиксированный порог убил бы единственный верный ответ.
|
|
167
|
+
*/
|
|
168
|
+
const NOISE_FLOOR_RATIO = 0.15;
|
|
169
|
+
/** Куда идти, когда поиск ничего не дал — тупиковый ответ отправляет агента читать node_modules. */
|
|
170
|
+
const EMPTY_RESULT_NOTICE = 'Ничего не найдено. Дальше стоит: list_components({type/category}) — посмотреть каталог целиком; ' +
|
|
171
|
+
'list_features({component}) — фичи конкретного компонента (у TableCanvas их 46, имена вроде ' +
|
|
172
|
+
'CopyPasteFill/massPanelAction не угадываются); get_component_props({name}) — типы полей, ' +
|
|
173
|
+
'если известен компонент, но не известно имя типа.';
|
|
174
|
+
/**
|
|
175
|
+
* Простой скоринг по имени/description/docs/hint (без внешних NLP-зависимостей),
|
|
176
|
+
* плюс поиск по фичам наравне с компонентами — запрос "фильтрация в таблице"
|
|
177
|
+
* должен находить TableCanvas/Filtering, а не только сам компонент. Legacy
|
|
178
|
+
* понижается штрафом, а не исключается — явное упоминание имени (точное
|
|
179
|
+
* совпадение слова, +100) перевешивает штраф, так что "Table сортировка"
|
|
180
|
+
* всё равно ставит Table выше TableCanvas.
|
|
181
|
+
*/
|
|
182
|
+
export function searchComponents(index, { query, limit = 15 } = {}) {
|
|
183
|
+
const tokens = tokenize(query);
|
|
184
|
+
if (tokens.length === 0) {
|
|
185
|
+
return { results: [], notice: EMPTY_RESULT_NOTICE };
|
|
186
|
+
}
|
|
187
|
+
const componentResults = Object.values(index.components)
|
|
188
|
+
.filter(isOkComponent)
|
|
189
|
+
.map((c) => ({
|
|
190
|
+
kind: 'component',
|
|
191
|
+
score: scoreComponent(c, tokens),
|
|
192
|
+
record: c,
|
|
193
|
+
}))
|
|
194
|
+
.filter((r) => r.score > 0);
|
|
195
|
+
const featureResults = index.features
|
|
196
|
+
.map((f) => ({
|
|
197
|
+
kind: 'feature',
|
|
198
|
+
score: scoreFeature(f, tokens),
|
|
199
|
+
record: f,
|
|
200
|
+
}))
|
|
201
|
+
.filter((r) => r.score > 0);
|
|
202
|
+
const typeResults = Object.entries(index.types)
|
|
203
|
+
.map(([key, record]) => ({
|
|
204
|
+
kind: 'type',
|
|
205
|
+
score: scoreType(record, tokens),
|
|
206
|
+
key,
|
|
207
|
+
record,
|
|
208
|
+
}))
|
|
209
|
+
.filter((r) => r.score > 0);
|
|
210
|
+
const scored = [
|
|
211
|
+
...componentResults,
|
|
212
|
+
...featureResults,
|
|
213
|
+
...typeResults,
|
|
214
|
+
].sort((a, b) => b.score - a.score);
|
|
215
|
+
const best = scored[0]?.score ?? 0;
|
|
216
|
+
const hits = scored
|
|
217
|
+
.filter((hit) => hit.score >= best * NOISE_FLOOR_RATIO)
|
|
218
|
+
.slice(0, limit);
|
|
219
|
+
const results = hits.map((hit) => {
|
|
220
|
+
if (hit.kind === 'type') {
|
|
221
|
+
return {
|
|
222
|
+
kind: hit.kind,
|
|
223
|
+
score: hit.score,
|
|
224
|
+
name: hit.key,
|
|
225
|
+
importPath: hit.record.importPath,
|
|
226
|
+
internal: hit.record.internal,
|
|
227
|
+
definitionPreview: firstLine(hit.record.definition),
|
|
228
|
+
};
|
|
229
|
+
}
|
|
230
|
+
if (hit.kind === 'component') {
|
|
231
|
+
return {
|
|
232
|
+
kind: hit.kind,
|
|
233
|
+
score: hit.score,
|
|
234
|
+
name: hit.record.name,
|
|
235
|
+
type: hit.record.type,
|
|
236
|
+
category: hit.record.category,
|
|
237
|
+
description: hit.record.description,
|
|
238
|
+
hint: hit.record.hint,
|
|
239
|
+
keywords: hit.record.keywords,
|
|
240
|
+
legacy: hit.record.legacy || undefined,
|
|
241
|
+
supersededBy: hit.record.supersededBy,
|
|
242
|
+
chooseWhen: hit.record.chooseWhen,
|
|
243
|
+
role: hit.record.role !== 'primary' ? hit.record.role : undefined,
|
|
244
|
+
parentComponent: hit.record.parentComponent,
|
|
245
|
+
};
|
|
246
|
+
}
|
|
247
|
+
return {
|
|
248
|
+
kind: hit.kind,
|
|
249
|
+
score: hit.score,
|
|
250
|
+
component: hit.record.component,
|
|
251
|
+
feature: hit.record.feature,
|
|
252
|
+
summary: hit.record.summary,
|
|
253
|
+
legacy: hit.record.legacy || undefined,
|
|
254
|
+
};
|
|
255
|
+
});
|
|
256
|
+
return results.length > 0
|
|
257
|
+
? { results }
|
|
258
|
+
: { results, notice: EMPTY_RESULT_NOTICE };
|
|
259
|
+
}
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
/** Точное совпадение имени, а с фолбеком на регистронезависимое — компонентов мало кто угадывает точно по регистру. */
|
|
2
|
+
export function findComponent(index, name) {
|
|
3
|
+
if (!name)
|
|
4
|
+
return undefined;
|
|
5
|
+
const direct = index.components[name];
|
|
6
|
+
if (direct)
|
|
7
|
+
return direct;
|
|
8
|
+
const lower = name.toLowerCase();
|
|
9
|
+
return Object.values(index.components).find((c) => c.name.toLowerCase() === lower);
|
|
10
|
+
}
|
|
11
|
+
/**
|
|
12
|
+
* Резолв фичи — регистронезависимый, с поддержкой вложенных путей
|
|
13
|
+
* (CanvasElements/CanvasText у TableCanvas против filtering/Filtering
|
|
14
|
+
* разного регистра у Table/TableCanvas).
|
|
15
|
+
*/
|
|
16
|
+
export function findFeature(index, component, feature) {
|
|
17
|
+
if (!component || !feature)
|
|
18
|
+
return undefined;
|
|
19
|
+
const componentLower = component.toLowerCase();
|
|
20
|
+
const featureLower = feature.toLowerCase();
|
|
21
|
+
return index.features.find((f) => f.component.toLowerCase() === componentLower &&
|
|
22
|
+
f.feature.toLowerCase() === featureLower);
|
|
23
|
+
}
|
|
24
|
+
export function listComponentFeatures(index, component) {
|
|
25
|
+
const componentLower = component.toLowerCase();
|
|
26
|
+
return index.features.filter((f) => f.component.toLowerCase() === componentLower);
|
|
27
|
+
}
|
|
28
|
+
/** Текст типа в компактных списках не должен весить как get_component_props — длинные union-литералы там не нужны. */
|
|
29
|
+
const COMPACT_PROP_TYPE_MAX_CHARS = 80;
|
|
30
|
+
function clipType(type) {
|
|
31
|
+
return type.length > COMPACT_PROP_TYPE_MAX_CHARS
|
|
32
|
+
? `${type.slice(0, COMPACT_PROP_TYPE_MAX_CHARS)}…`
|
|
33
|
+
: type;
|
|
34
|
+
}
|
|
35
|
+
/** Компактная сводка пропса — без description, для "лёгких" списков (get_component). */
|
|
36
|
+
export function summarizeProp(prop) {
|
|
37
|
+
return `${prop.name}${prop.required ? '' : '?'}: ${clipType(prop.type)}`;
|
|
38
|
+
}
|
|
@@ -0,0 +1,80 @@
|
|
|
1
|
+
export const RESPONSE_BUDGET_CHARS = 25000;
|
|
2
|
+
/**
|
|
3
|
+
* Бюджетирует список поэлементно: сериализует кандидатов один за другим и
|
|
4
|
+
* добирает элементы, пока итоговый (pretty-printed, как его увидит агент
|
|
5
|
+
* через truncateForResponse) JSON помещается в бюджет. В отличие от среза
|
|
6
|
+
* строки, всегда возвращает валидный объект — не может разрезать элемент
|
|
7
|
+
* пополам.
|
|
8
|
+
*/
|
|
9
|
+
function notice(shownCount, total) {
|
|
10
|
+
return `Показано ${shownCount} из ${total}. Уточните запрос фильтрами либо используйте limit/offset (где поддерживается), чтобы получить остаток.`;
|
|
11
|
+
}
|
|
12
|
+
export function truncateList(items, budget = RESPONSE_BUDGET_CHARS) {
|
|
13
|
+
const total = items.length;
|
|
14
|
+
const shown = [];
|
|
15
|
+
for (const item of items) {
|
|
16
|
+
const shownCount = shown.length + 1;
|
|
17
|
+
const candidate = {
|
|
18
|
+
items: [...shown, item],
|
|
19
|
+
shown: shownCount,
|
|
20
|
+
total,
|
|
21
|
+
...(shownCount < total
|
|
22
|
+
? { truncationNotice: notice(shownCount, total) }
|
|
23
|
+
: {}),
|
|
24
|
+
};
|
|
25
|
+
if (JSON.stringify(candidate, null, 2).length > budget &&
|
|
26
|
+
shown.length > 0) {
|
|
27
|
+
break;
|
|
28
|
+
}
|
|
29
|
+
shown.push(item);
|
|
30
|
+
}
|
|
31
|
+
const result = { items: shown, shown: shown.length, total };
|
|
32
|
+
if (shown.length < total) {
|
|
33
|
+
result.truncationNotice = notice(shown.length, total);
|
|
34
|
+
}
|
|
35
|
+
return result;
|
|
36
|
+
}
|
|
37
|
+
/**
|
|
38
|
+
* Последний рубеж защиты бюджета ответа. Каждый инструмент уже спроектирован
|
|
39
|
+
* компактным по построению (get_component без тел примеров, list_features без
|
|
40
|
+
* apiDocs и т.д.), а списочные ответы бюджетируются заранее через
|
|
41
|
+
* truncateList — это подстраховка на случай, если конкретная запись всё
|
|
42
|
+
* равно оказалась больше расчётного бюджета (see: TableCanvas — 682k символов
|
|
43
|
+
* в сыром meta.json на один компонент).
|
|
44
|
+
*
|
|
45
|
+
* В отличие от старой реализации, никогда не режет сериализованную строку
|
|
46
|
+
* посередине: результат всегда валидный JSON — обрезается только текстовое
|
|
47
|
+
* значение внутри поля `raw`.
|
|
48
|
+
*/
|
|
49
|
+
export function truncateForResponse(payload, budget = RESPONSE_BUDGET_CHARS) {
|
|
50
|
+
const text = JSON.stringify(payload, null, 2);
|
|
51
|
+
if (text.length <= budget)
|
|
52
|
+
return text;
|
|
53
|
+
const notice = `Ответ обрезан: ${text.length} символов исходно, показано начало (обрезка внутри поля raw, JSON снаружи валиден). Уточните запрос — используйте part/title/feature у соответствующего инструмента, чтобы получить нужный срез точечно.`;
|
|
54
|
+
const build = (rawLen) => JSON.stringify({
|
|
55
|
+
truncated: true,
|
|
56
|
+
totalChars: text.length,
|
|
57
|
+
notice,
|
|
58
|
+
raw: text.slice(0, rawLen),
|
|
59
|
+
}, null, 2);
|
|
60
|
+
// Экранирование спецсимволов внутри raw (кавычки, переносы строк — их много
|
|
61
|
+
// в pretty-printed JSON) может увеличить длину сериализованного результата
|
|
62
|
+
// сильнее, чем длина самого среза, поэтому простое вычитание overhead один
|
|
63
|
+
// раз не гарантирует итоговый размер — ищем бинарным поиском максимальный
|
|
64
|
+
// rawLen, при котором результат всё ещё укладывается в бюджет.
|
|
65
|
+
let lo = 0;
|
|
66
|
+
let hi = Math.min(text.length, budget);
|
|
67
|
+
let best = build(0);
|
|
68
|
+
while (lo <= hi) {
|
|
69
|
+
const mid = Math.floor((lo + hi) / 2);
|
|
70
|
+
const candidate = build(mid);
|
|
71
|
+
if (candidate.length <= budget) {
|
|
72
|
+
best = candidate;
|
|
73
|
+
lo = mid + 1;
|
|
74
|
+
}
|
|
75
|
+
else {
|
|
76
|
+
hi = mid - 1;
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
return best;
|
|
80
|
+
}
|
package/dist/types.js
ADDED
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
/* ─────────────── Пропсы ─────────────── */
|
|
2
|
+
/** Сужающий guard — `.filter()` сам по себе тип не сужает. */
|
|
3
|
+
export function isOkComponent(record) {
|
|
4
|
+
return record.error === undefined;
|
|
5
|
+
}
|
|
6
|
+
export function isToolError(result) {
|
|
7
|
+
return typeof result === 'object' && result !== null && 'error' in result;
|
|
8
|
+
}
|
package/package.json
ADDED
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "@digital-finance-ui/ui-kit-mcp",
|
|
3
|
+
"version": "0.2.3",
|
|
4
|
+
"description": "MCP server for @sber-digital-finance-ui/ui-kit — component discovery, props and examples for coding agents",
|
|
5
|
+
"type": "module",
|
|
6
|
+
"bin": {
|
|
7
|
+
"digital-finance-ui-ui-kit-mcp": "./dist/server.js"
|
|
8
|
+
},
|
|
9
|
+
"main": "./dist/server.js",
|
|
10
|
+
"files": [
|
|
11
|
+
"dist",
|
|
12
|
+
"data"
|
|
13
|
+
],
|
|
14
|
+
"license": "MIT",
|
|
15
|
+
"publishConfig": {
|
|
16
|
+
"access": "public"
|
|
17
|
+
},
|
|
18
|
+
"dependencies": {
|
|
19
|
+
"@modelcontextprotocol/sdk": "^1.0.0",
|
|
20
|
+
"zod": "^3.24.2"
|
|
21
|
+
},
|
|
22
|
+
"engines": {
|
|
23
|
+
"node": ">=20.0.0"
|
|
24
|
+
}
|
|
25
|
+
}
|