@ourroadmaps/mcp 0.24.0 → 0.25.0
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/dist/index.js +1229 -388
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -223,298 +223,445 @@ var updateIdeaSchema = z6.object({
|
|
|
223
223
|
order: z6.number().int().optional()
|
|
224
224
|
});
|
|
225
225
|
var ideaListSchema = z6.array(ideaSchema);
|
|
226
|
-
// ../../packages/shared/src/schemas/
|
|
226
|
+
// ../../packages/shared/src/schemas/presentation.ts
|
|
227
227
|
import { z as z7 } from "zod";
|
|
228
|
-
var
|
|
228
|
+
var presentationSchema = z7.object({
|
|
229
229
|
id: z7.string().uuid(),
|
|
230
230
|
organizationId: z7.string(),
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
name: z7.string(),
|
|
231
|
+
title: z7.string(),
|
|
232
|
+
description: z7.string().nullable(),
|
|
234
233
|
order: z7.number().int(),
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
234
|
+
createdAt: z7.string(),
|
|
235
|
+
createdBy: z7.string(),
|
|
236
|
+
updatedAt: z7.string().nullable()
|
|
237
|
+
});
|
|
238
|
+
var createPresentationSchema = z7.object({
|
|
239
|
+
title: z7.string().min(1),
|
|
240
|
+
description: z7.string().nullable().optional()
|
|
241
|
+
});
|
|
242
|
+
var updatePresentationSchema = z7.object({
|
|
243
|
+
title: z7.string().min(1).optional(),
|
|
244
|
+
description: z7.string().nullable().optional()
|
|
245
|
+
});
|
|
246
|
+
var presentationListSchema = z7.array(presentationSchema);
|
|
247
|
+
// ../../packages/shared/src/schemas/product.ts
|
|
248
|
+
import { z as z8 } from "zod";
|
|
249
|
+
var productSchema = z8.object({
|
|
250
|
+
id: z8.string().uuid(),
|
|
251
|
+
organizationId: z8.string(),
|
|
252
|
+
parentId: z8.string().uuid().nullable(),
|
|
253
|
+
type: productTypeSchema,
|
|
254
|
+
name: z8.string(),
|
|
255
|
+
order: z8.number().int(),
|
|
256
|
+
isExpanded: z8.boolean(),
|
|
257
|
+
deletedAt: z8.string().nullable(),
|
|
258
|
+
createdAt: z8.string()
|
|
238
259
|
});
|
|
239
|
-
var createProductSchema =
|
|
240
|
-
name:
|
|
241
|
-
description:
|
|
260
|
+
var createProductSchema = z8.object({
|
|
261
|
+
name: z8.string().min(1),
|
|
262
|
+
description: z8.string().nullable().optional(),
|
|
242
263
|
type: productTypeSchema,
|
|
243
|
-
parentId:
|
|
264
|
+
parentId: z8.string().uuid().nullable().optional()
|
|
244
265
|
});
|
|
245
|
-
var updateProductSchema =
|
|
246
|
-
name:
|
|
247
|
-
description:
|
|
266
|
+
var updateProductSchema = z8.object({
|
|
267
|
+
name: z8.string().min(1).optional(),
|
|
268
|
+
description: z8.string().nullable().optional(),
|
|
248
269
|
type: productTypeSchema.optional(),
|
|
249
|
-
parentId:
|
|
250
|
-
order:
|
|
270
|
+
parentId: z8.string().uuid().nullable().optional(),
|
|
271
|
+
order: z8.number().int().optional()
|
|
251
272
|
});
|
|
252
|
-
var productListSchema =
|
|
273
|
+
var productListSchema = z8.array(productSchema);
|
|
253
274
|
// ../../packages/shared/src/schemas/roadmap.ts
|
|
254
|
-
import { z as
|
|
275
|
+
import { z as z10 } from "zod";
|
|
255
276
|
|
|
256
277
|
// ../../packages/shared/src/schemas/story.ts
|
|
257
|
-
import { z as
|
|
258
|
-
var epicSchema =
|
|
259
|
-
id:
|
|
260
|
-
roadmapItemId:
|
|
261
|
-
organizationId:
|
|
262
|
-
title:
|
|
263
|
-
description:
|
|
264
|
-
order:
|
|
265
|
-
createdAt:
|
|
266
|
-
updatedAt:
|
|
267
|
-
deletedAt:
|
|
278
|
+
import { z as z9 } from "zod";
|
|
279
|
+
var epicSchema = z9.object({
|
|
280
|
+
id: z9.string().uuid(),
|
|
281
|
+
roadmapItemId: z9.string().uuid(),
|
|
282
|
+
organizationId: z9.string(),
|
|
283
|
+
title: z9.string(),
|
|
284
|
+
description: z9.string().nullable(),
|
|
285
|
+
order: z9.number().int(),
|
|
286
|
+
createdAt: z9.string(),
|
|
287
|
+
updatedAt: z9.string(),
|
|
288
|
+
deletedAt: z9.string().nullable()
|
|
268
289
|
});
|
|
269
|
-
var storySchema =
|
|
270
|
-
id:
|
|
271
|
-
roadmapItemId:
|
|
272
|
-
epicId:
|
|
273
|
-
organizationId:
|
|
274
|
-
title:
|
|
275
|
-
description:
|
|
276
|
-
order:
|
|
277
|
-
createdAt:
|
|
278
|
-
updatedAt:
|
|
279
|
-
deletedAt:
|
|
290
|
+
var storySchema = z9.object({
|
|
291
|
+
id: z9.string().uuid(),
|
|
292
|
+
roadmapItemId: z9.string().uuid(),
|
|
293
|
+
epicId: z9.string().uuid().nullable(),
|
|
294
|
+
organizationId: z9.string(),
|
|
295
|
+
title: z9.string(),
|
|
296
|
+
description: z9.string().nullable(),
|
|
297
|
+
order: z9.number().int(),
|
|
298
|
+
createdAt: z9.string(),
|
|
299
|
+
updatedAt: z9.string(),
|
|
300
|
+
deletedAt: z9.string().nullable()
|
|
280
301
|
});
|
|
281
302
|
var epicWithStoriesSchema = epicSchema.extend({
|
|
282
|
-
stories:
|
|
283
|
-
});
|
|
284
|
-
var createEpicSchema =
|
|
285
|
-
title:
|
|
286
|
-
description:
|
|
287
|
-
});
|
|
288
|
-
var createStorySchema =
|
|
289
|
-
title:
|
|
290
|
-
description:
|
|
291
|
-
});
|
|
292
|
-
var saveStoriesInputSchema =
|
|
293
|
-
epics:
|
|
294
|
-
title:
|
|
295
|
-
description:
|
|
296
|
-
stories:
|
|
297
|
-
title:
|
|
298
|
-
description:
|
|
303
|
+
stories: z9.array(storySchema)
|
|
304
|
+
});
|
|
305
|
+
var createEpicSchema = z9.object({
|
|
306
|
+
title: z9.string().min(1),
|
|
307
|
+
description: z9.string().nullable().optional()
|
|
308
|
+
});
|
|
309
|
+
var createStorySchema = z9.object({
|
|
310
|
+
title: z9.string().min(1),
|
|
311
|
+
description: z9.string().nullable().optional()
|
|
312
|
+
});
|
|
313
|
+
var saveStoriesInputSchema = z9.object({
|
|
314
|
+
epics: z9.array(z9.object({
|
|
315
|
+
title: z9.string().min(1),
|
|
316
|
+
description: z9.string().nullable().optional(),
|
|
317
|
+
stories: z9.array(z9.object({
|
|
318
|
+
title: z9.string().min(1),
|
|
319
|
+
description: z9.string().nullable().optional()
|
|
299
320
|
})).optional().default([])
|
|
300
321
|
})).optional().default([]),
|
|
301
|
-
stories:
|
|
302
|
-
title:
|
|
303
|
-
description:
|
|
322
|
+
stories: z9.array(z9.object({
|
|
323
|
+
title: z9.string().min(1),
|
|
324
|
+
description: z9.string().nullable().optional()
|
|
304
325
|
})).optional().default([])
|
|
305
326
|
});
|
|
306
|
-
var updateEpicSchema =
|
|
307
|
-
title:
|
|
308
|
-
description:
|
|
327
|
+
var updateEpicSchema = z9.object({
|
|
328
|
+
title: z9.string().min(1).optional(),
|
|
329
|
+
description: z9.string().nullable().optional()
|
|
309
330
|
});
|
|
310
|
-
var updateStorySchema =
|
|
311
|
-
title:
|
|
312
|
-
description:
|
|
313
|
-
epicId:
|
|
331
|
+
var updateStorySchema = z9.object({
|
|
332
|
+
title: z9.string().min(1).optional(),
|
|
333
|
+
description: z9.string().nullable().optional(),
|
|
334
|
+
epicId: z9.string().uuid().nullable().optional()
|
|
314
335
|
});
|
|
315
|
-
var reorderStoriesSchema =
|
|
316
|
-
epicOrder:
|
|
317
|
-
storyOrder:
|
|
318
|
-
standaloneOrder:
|
|
336
|
+
var reorderStoriesSchema = z9.object({
|
|
337
|
+
epicOrder: z9.array(z9.string().uuid()).optional(),
|
|
338
|
+
storyOrder: z9.record(z9.string(), z9.array(z9.string().uuid())).optional(),
|
|
339
|
+
standaloneOrder: z9.array(z9.string().uuid()).optional()
|
|
319
340
|
});
|
|
320
341
|
|
|
321
342
|
// ../../packages/shared/src/schemas/roadmap.ts
|
|
322
|
-
var flexibleDateSchema =
|
|
323
|
-
value:
|
|
343
|
+
var flexibleDateSchema = z10.object({
|
|
344
|
+
value: z10.string(),
|
|
324
345
|
granularity: dateGranularitySchema
|
|
325
346
|
});
|
|
326
|
-
var labelSchema =
|
|
327
|
-
id:
|
|
328
|
-
type:
|
|
329
|
-
name:
|
|
330
|
-
color:
|
|
331
|
-
address:
|
|
347
|
+
var labelSchema = z10.object({
|
|
348
|
+
id: z10.string().uuid(),
|
|
349
|
+
type: z10.enum(["category", "location", "label"]),
|
|
350
|
+
name: z10.string(),
|
|
351
|
+
color: z10.string().nullable(),
|
|
352
|
+
address: z10.string().nullable()
|
|
332
353
|
});
|
|
333
|
-
var appSchema =
|
|
334
|
-
id:
|
|
335
|
-
name:
|
|
354
|
+
var appSchema = z10.object({
|
|
355
|
+
id: z10.string().uuid(),
|
|
356
|
+
name: z10.string()
|
|
336
357
|
});
|
|
337
|
-
var roadmapSchema =
|
|
338
|
-
id:
|
|
339
|
-
organizationId:
|
|
340
|
-
title:
|
|
358
|
+
var roadmapSchema = z10.object({
|
|
359
|
+
id: z10.string().uuid(),
|
|
360
|
+
organizationId: z10.string(),
|
|
361
|
+
title: z10.string(),
|
|
341
362
|
horizon: horizonSchema.nullable(),
|
|
342
363
|
status: roadmapStatusSchema.nullable(),
|
|
343
364
|
value: effortSchema.nullable(),
|
|
344
365
|
effort: effortSchema.nullable(),
|
|
345
|
-
order:
|
|
346
|
-
estimatedSeconds:
|
|
366
|
+
order: z10.number().int(),
|
|
367
|
+
estimatedSeconds: z10.number().int().nullable(),
|
|
347
368
|
date: flexibleDateSchema.nullable(),
|
|
348
369
|
target: flexibleDateSchema.nullable(),
|
|
349
|
-
completedAt:
|
|
350
|
-
createdAt:
|
|
351
|
-
createdBy:
|
|
352
|
-
prompt:
|
|
353
|
-
labels:
|
|
354
|
-
apps:
|
|
370
|
+
completedAt: z10.string().nullable(),
|
|
371
|
+
createdAt: z10.string(),
|
|
372
|
+
createdBy: z10.string(),
|
|
373
|
+
prompt: z10.string().nullable(),
|
|
374
|
+
labels: z10.array(labelSchema),
|
|
375
|
+
apps: z10.array(appSchema)
|
|
355
376
|
});
|
|
356
|
-
var createRoadmapSchema =
|
|
357
|
-
title:
|
|
377
|
+
var createRoadmapSchema = z10.object({
|
|
378
|
+
title: z10.string().min(1),
|
|
358
379
|
status: roadmapStatusSchema.optional(),
|
|
359
380
|
horizon: horizonSchema.optional(),
|
|
360
381
|
value: effortSchema.nullable().optional(),
|
|
361
382
|
effort: effortSchema.nullable().optional(),
|
|
362
|
-
estimatedSeconds:
|
|
383
|
+
estimatedSeconds: z10.number().int().nullable().optional(),
|
|
363
384
|
date: flexibleDateSchema.nullable().optional(),
|
|
364
385
|
target: flexibleDateSchema.nullable().optional(),
|
|
365
|
-
prompt:
|
|
366
|
-
brainstormNotes:
|
|
386
|
+
prompt: z10.string().nullable().optional(),
|
|
387
|
+
brainstormNotes: z10.string().nullable().optional()
|
|
367
388
|
});
|
|
368
|
-
var updateRoadmapSchema =
|
|
369
|
-
title:
|
|
389
|
+
var updateRoadmapSchema = z10.object({
|
|
390
|
+
title: z10.string().min(1).optional(),
|
|
370
391
|
status: roadmapStatusSchema.optional(),
|
|
371
392
|
horizon: horizonSchema.optional(),
|
|
372
393
|
value: effortSchema.nullable().optional(),
|
|
373
394
|
effort: effortSchema.nullable().optional(),
|
|
374
|
-
order:
|
|
375
|
-
estimatedSeconds:
|
|
395
|
+
order: z10.number().int().optional(),
|
|
396
|
+
estimatedSeconds: z10.number().int().nullable().optional(),
|
|
376
397
|
date: flexibleDateSchema.nullable().optional(),
|
|
377
398
|
target: flexibleDateSchema.nullable().optional(),
|
|
378
|
-
prompt:
|
|
379
|
-
brainstormNotes:
|
|
399
|
+
prompt: z10.string().nullable().optional(),
|
|
400
|
+
brainstormNotes: z10.string().nullable().optional()
|
|
380
401
|
});
|
|
381
|
-
var prdOutcomeSchema =
|
|
382
|
-
id:
|
|
383
|
-
description:
|
|
402
|
+
var prdOutcomeSchema = z10.object({
|
|
403
|
+
id: z10.string().uuid(),
|
|
404
|
+
description: z10.string(),
|
|
384
405
|
status: prdStatusSchema,
|
|
385
|
-
order:
|
|
386
|
-
completedAt:
|
|
406
|
+
order: z10.number().int(),
|
|
407
|
+
completedAt: z10.string().nullable()
|
|
387
408
|
});
|
|
388
|
-
var prdSchema =
|
|
389
|
-
id:
|
|
390
|
-
what:
|
|
391
|
-
why:
|
|
392
|
-
outcomes:
|
|
409
|
+
var prdSchema = z10.object({
|
|
410
|
+
id: z10.string().uuid(),
|
|
411
|
+
what: z10.string().nullable(),
|
|
412
|
+
why: z10.string().nullable(),
|
|
413
|
+
outcomes: z10.array(prdOutcomeSchema)
|
|
393
414
|
});
|
|
394
|
-
var savePrdInputSchema =
|
|
395
|
-
what:
|
|
396
|
-
why:
|
|
415
|
+
var savePrdInputSchema = z10.object({
|
|
416
|
+
what: z10.string().nullable(),
|
|
417
|
+
why: z10.string().nullable(),
|
|
397
418
|
status: prdStatusSchema,
|
|
398
|
-
outcomes:
|
|
399
|
-
id:
|
|
400
|
-
description:
|
|
401
|
-
order:
|
|
419
|
+
outcomes: z10.array(z10.object({
|
|
420
|
+
id: z10.string().uuid().optional(),
|
|
421
|
+
description: z10.string(),
|
|
422
|
+
order: z10.number().int().min(0)
|
|
402
423
|
}))
|
|
403
424
|
});
|
|
404
|
-
var brainstormMediaSchema =
|
|
405
|
-
id:
|
|
406
|
-
mediaUrl:
|
|
425
|
+
var brainstormMediaSchema = z10.object({
|
|
426
|
+
id: z10.string().uuid(),
|
|
427
|
+
mediaUrl: z10.string(),
|
|
407
428
|
mediaType: brainstormMediaTypeSchema,
|
|
408
|
-
description:
|
|
409
|
-
order:
|
|
410
|
-
createdAt:
|
|
429
|
+
description: z10.string().nullable(),
|
|
430
|
+
order: z10.number().int(),
|
|
431
|
+
createdAt: z10.string()
|
|
411
432
|
});
|
|
412
|
-
var wireframeSchema =
|
|
413
|
-
id:
|
|
414
|
-
description:
|
|
415
|
-
imageUrl:
|
|
416
|
-
order:
|
|
433
|
+
var wireframeSchema = z10.object({
|
|
434
|
+
id: z10.string().uuid(),
|
|
435
|
+
description: z10.string().nullable(),
|
|
436
|
+
imageUrl: z10.string().nullable(),
|
|
437
|
+
order: z10.number().int()
|
|
417
438
|
});
|
|
418
|
-
var prototypeSchema =
|
|
419
|
-
id:
|
|
420
|
-
publicUrl:
|
|
421
|
-
expiresAt:
|
|
422
|
-
fileCount:
|
|
423
|
-
entryPoint:
|
|
424
|
-
createdAt:
|
|
439
|
+
var prototypeSchema = z10.object({
|
|
440
|
+
id: z10.string().uuid(),
|
|
441
|
+
publicUrl: z10.string().url(),
|
|
442
|
+
expiresAt: z10.string().datetime(),
|
|
443
|
+
fileCount: z10.number().int().positive(),
|
|
444
|
+
entryPoint: z10.string(),
|
|
445
|
+
createdAt: z10.string().datetime()
|
|
425
446
|
});
|
|
426
|
-
var featureLinkSchema =
|
|
427
|
-
id:
|
|
428
|
-
featureId:
|
|
429
|
-
feature:
|
|
430
|
-
id:
|
|
431
|
-
name:
|
|
432
|
-
type:
|
|
447
|
+
var featureLinkSchema = z10.object({
|
|
448
|
+
id: z10.string().uuid(),
|
|
449
|
+
featureId: z10.string().uuid(),
|
|
450
|
+
feature: z10.object({
|
|
451
|
+
id: z10.string().uuid(),
|
|
452
|
+
name: z10.string(),
|
|
453
|
+
type: z10.enum(["area", "feature"])
|
|
433
454
|
}),
|
|
434
|
-
createdAt:
|
|
455
|
+
createdAt: z10.string()
|
|
435
456
|
});
|
|
436
|
-
var phaseDesignSchema =
|
|
437
|
-
id:
|
|
438
|
-
description:
|
|
457
|
+
var phaseDesignSchema = z10.object({
|
|
458
|
+
id: z10.string().uuid(),
|
|
459
|
+
description: z10.string().nullable()
|
|
439
460
|
});
|
|
440
|
-
var phasePlanSchema =
|
|
441
|
-
id:
|
|
442
|
-
description:
|
|
461
|
+
var phasePlanSchema = z10.object({
|
|
462
|
+
id: z10.string().uuid(),
|
|
463
|
+
description: z10.string().nullable()
|
|
443
464
|
});
|
|
444
|
-
var phaseBuildSchema =
|
|
445
|
-
id:
|
|
446
|
-
description:
|
|
447
|
-
prompt:
|
|
465
|
+
var phaseBuildSchema = z10.object({
|
|
466
|
+
id: z10.string().uuid(),
|
|
467
|
+
description: z10.string().nullable(),
|
|
468
|
+
prompt: z10.string().nullable()
|
|
448
469
|
});
|
|
449
|
-
var phaseReleaseSchema =
|
|
450
|
-
id:
|
|
451
|
-
description:
|
|
470
|
+
var phaseReleaseSchema = z10.object({
|
|
471
|
+
id: z10.string().uuid(),
|
|
472
|
+
description: z10.string().nullable()
|
|
452
473
|
});
|
|
453
474
|
var roadmapDetailSchema = roadmapSchema.extend({
|
|
454
475
|
prd: prdSchema.nullable(),
|
|
455
|
-
wireframes:
|
|
456
|
-
prototypes:
|
|
457
|
-
brainstormMedia:
|
|
458
|
-
brainstormNotes:
|
|
459
|
-
featureLinks:
|
|
460
|
-
epics:
|
|
461
|
-
stories:
|
|
476
|
+
wireframes: z10.array(wireframeSchema),
|
|
477
|
+
prototypes: z10.array(prototypeSchema),
|
|
478
|
+
brainstormMedia: z10.array(brainstormMediaSchema),
|
|
479
|
+
brainstormNotes: z10.string().nullable(),
|
|
480
|
+
featureLinks: z10.array(featureLinkSchema),
|
|
481
|
+
epics: z10.array(epicWithStoriesSchema),
|
|
482
|
+
stories: z10.array(storySchema),
|
|
462
483
|
design: phaseDesignSchema.nullable(),
|
|
463
484
|
plan: phasePlanSchema.nullable(),
|
|
464
485
|
build: phaseBuildSchema.nullable(),
|
|
465
486
|
release: phaseReleaseSchema.nullable(),
|
|
466
|
-
exports:
|
|
487
|
+
exports: z10.array(exportSchema)
|
|
467
488
|
});
|
|
468
|
-
var roadmapListSchema =
|
|
489
|
+
var roadmapListSchema = z10.array(roadmapSchema);
|
|
469
490
|
// ../../packages/shared/src/schemas/scenario.ts
|
|
470
|
-
import { z as
|
|
471
|
-
var scenarioSchema =
|
|
472
|
-
id:
|
|
473
|
-
title:
|
|
474
|
-
given:
|
|
475
|
-
when:
|
|
476
|
-
then:
|
|
477
|
-
order:
|
|
478
|
-
createdAt:
|
|
479
|
-
updatedAt:
|
|
491
|
+
import { z as z11 } from "zod";
|
|
492
|
+
var scenarioSchema = z11.object({
|
|
493
|
+
id: z11.string().uuid(),
|
|
494
|
+
title: z11.string().min(1),
|
|
495
|
+
given: z11.string().nullable(),
|
|
496
|
+
when: z11.string().nullable(),
|
|
497
|
+
then: z11.string().nullable(),
|
|
498
|
+
order: z11.number().int(),
|
|
499
|
+
createdAt: z11.string().datetime(),
|
|
500
|
+
updatedAt: z11.string().datetime()
|
|
480
501
|
});
|
|
481
|
-
var createScenarioSchema =
|
|
482
|
-
title:
|
|
483
|
-
given:
|
|
484
|
-
when:
|
|
485
|
-
then:
|
|
486
|
-
roadmapId:
|
|
502
|
+
var createScenarioSchema = z11.object({
|
|
503
|
+
title: z11.string().min(1),
|
|
504
|
+
given: z11.string().nullable().optional(),
|
|
505
|
+
when: z11.string().nullable().optional(),
|
|
506
|
+
then: z11.string().nullable().optional(),
|
|
507
|
+
roadmapId: z11.string().uuid()
|
|
487
508
|
});
|
|
488
|
-
var updateScenarioSchema =
|
|
489
|
-
title:
|
|
490
|
-
given:
|
|
491
|
-
when:
|
|
492
|
-
then:
|
|
493
|
-
order:
|
|
509
|
+
var updateScenarioSchema = z11.object({
|
|
510
|
+
title: z11.string().min(1).optional(),
|
|
511
|
+
given: z11.string().nullable().optional(),
|
|
512
|
+
when: z11.string().nullable().optional(),
|
|
513
|
+
then: z11.string().nullable().optional(),
|
|
514
|
+
order: z11.number().int().optional()
|
|
515
|
+
});
|
|
516
|
+
var scenarioListSchema = z11.array(scenarioSchema);
|
|
517
|
+
// ../../packages/shared/src/schemas/slide.ts
|
|
518
|
+
import { z as z12 } from "zod";
|
|
519
|
+
var SLIDE_TYPES = [
|
|
520
|
+
"title",
|
|
521
|
+
"section_header",
|
|
522
|
+
"bullets",
|
|
523
|
+
"two_column",
|
|
524
|
+
"comparison",
|
|
525
|
+
"timeline",
|
|
526
|
+
"image",
|
|
527
|
+
"quote",
|
|
528
|
+
"code",
|
|
529
|
+
"thank_you"
|
|
530
|
+
];
|
|
531
|
+
var slideTypeSchema = z12.enum(SLIDE_TYPES);
|
|
532
|
+
var titleContentSchema = z12.object({
|
|
533
|
+
title: z12.string(),
|
|
534
|
+
subtitle: z12.string().optional()
|
|
494
535
|
});
|
|
495
|
-
var
|
|
536
|
+
var sectionHeaderContentSchema = z12.object({
|
|
537
|
+
title: z12.string(),
|
|
538
|
+
subtitle: z12.string().optional()
|
|
539
|
+
});
|
|
540
|
+
var bulletsContentSchema = z12.object({
|
|
541
|
+
title: z12.string().optional(),
|
|
542
|
+
items: z12.array(z12.string()).default([])
|
|
543
|
+
});
|
|
544
|
+
var twoColumnContentSchema = z12.object({
|
|
545
|
+
title: z12.string().optional(),
|
|
546
|
+
left: z12.string().default(""),
|
|
547
|
+
right: z12.string().default("")
|
|
548
|
+
});
|
|
549
|
+
var comparisonContentSchema = z12.object({
|
|
550
|
+
leftLabel: z12.string().default(""),
|
|
551
|
+
leftContent: z12.string().default(""),
|
|
552
|
+
rightLabel: z12.string().default(""),
|
|
553
|
+
rightContent: z12.string().default("")
|
|
554
|
+
});
|
|
555
|
+
var timelineStepSchema = z12.object({
|
|
556
|
+
title: z12.string(),
|
|
557
|
+
description: z12.string().optional()
|
|
558
|
+
});
|
|
559
|
+
var timelineContentSchema = z12.object({
|
|
560
|
+
title: z12.string().optional(),
|
|
561
|
+
steps: z12.array(timelineStepSchema).default([])
|
|
562
|
+
});
|
|
563
|
+
var imageContentSchema = z12.object({
|
|
564
|
+
title: z12.string().optional(),
|
|
565
|
+
imageUrl: z12.string().optional(),
|
|
566
|
+
caption: z12.string().optional()
|
|
567
|
+
});
|
|
568
|
+
var quoteContentSchema = z12.object({
|
|
569
|
+
quote: z12.string().default(""),
|
|
570
|
+
attribution: z12.string().optional()
|
|
571
|
+
});
|
|
572
|
+
var codeContentSchema = z12.object({
|
|
573
|
+
title: z12.string().optional(),
|
|
574
|
+
code: z12.string().default(""),
|
|
575
|
+
language: z12.string().optional(),
|
|
576
|
+
highlightLines: z12.array(z12.number()).optional()
|
|
577
|
+
});
|
|
578
|
+
var thankYouContentSchema = z12.object({
|
|
579
|
+
title: z12.string().default("Thank You"),
|
|
580
|
+
subtitle: z12.string().optional(),
|
|
581
|
+
ctaText: z12.string().optional(),
|
|
582
|
+
ctaUrl: z12.string().optional()
|
|
583
|
+
});
|
|
584
|
+
var typedSlideContentSchema = z12.discriminatedUnion("type", [
|
|
585
|
+
z12.object({ type: z12.literal("title"), ...titleContentSchema.shape }),
|
|
586
|
+
z12.object({ type: z12.literal("section_header"), ...sectionHeaderContentSchema.shape }),
|
|
587
|
+
z12.object({ type: z12.literal("bullets"), ...bulletsContentSchema.shape }),
|
|
588
|
+
z12.object({ type: z12.literal("two_column"), ...twoColumnContentSchema.shape }),
|
|
589
|
+
z12.object({ type: z12.literal("comparison"), ...comparisonContentSchema.shape }),
|
|
590
|
+
z12.object({ type: z12.literal("timeline"), ...timelineContentSchema.shape }),
|
|
591
|
+
z12.object({ type: z12.literal("image"), ...imageContentSchema.shape }),
|
|
592
|
+
z12.object({ type: z12.literal("quote"), ...quoteContentSchema.shape }),
|
|
593
|
+
z12.object({ type: z12.literal("code"), ...codeContentSchema.shape }),
|
|
594
|
+
z12.object({ type: z12.literal("thank_you"), ...thankYouContentSchema.shape })
|
|
595
|
+
]);
|
|
596
|
+
var slideContentSchema = z12.object({
|
|
597
|
+
body: z12.string().optional()
|
|
598
|
+
});
|
|
599
|
+
var slideSchema = z12.object({
|
|
600
|
+
id: z12.string().uuid(),
|
|
601
|
+
variantId: z12.string().uuid(),
|
|
602
|
+
slideType: slideTypeSchema,
|
|
603
|
+
title: z12.string(),
|
|
604
|
+
content: z12.unknown().nullable(),
|
|
605
|
+
speakerNotes: z12.string().nullable(),
|
|
606
|
+
order: z12.number().int(),
|
|
607
|
+
createdAt: z12.string(),
|
|
608
|
+
createdBy: z12.string(),
|
|
609
|
+
updatedAt: z12.string().nullable()
|
|
610
|
+
});
|
|
611
|
+
var createSlideSchema = z12.object({
|
|
612
|
+
slideType: slideTypeSchema,
|
|
613
|
+
content: z12.unknown().optional(),
|
|
614
|
+
speakerNotes: z12.string().nullable().optional()
|
|
615
|
+
});
|
|
616
|
+
var updateSlideSchema = z12.object({
|
|
617
|
+
content: z12.unknown().optional(),
|
|
618
|
+
speakerNotes: z12.string().nullable().optional()
|
|
619
|
+
});
|
|
620
|
+
var slideListSchema = z12.array(slideSchema);
|
|
496
621
|
// ../../packages/shared/src/schemas/status-update.ts
|
|
497
|
-
import { z as
|
|
498
|
-
var statusUpdateItemSchema =
|
|
499
|
-
id:
|
|
500
|
-
roadmapItemId:
|
|
501
|
-
titleAtSnapshot:
|
|
502
|
-
statusAtSnapshot:
|
|
503
|
-
designWalkthroughUrl:
|
|
504
|
-
releaseWalkthroughUrl:
|
|
622
|
+
import { z as z13 } from "zod";
|
|
623
|
+
var statusUpdateItemSchema = z13.object({
|
|
624
|
+
id: z13.string().uuid(),
|
|
625
|
+
roadmapItemId: z13.string().uuid(),
|
|
626
|
+
titleAtSnapshot: z13.string(),
|
|
627
|
+
statusAtSnapshot: z13.string(),
|
|
628
|
+
designWalkthroughUrl: z13.string().nullable(),
|
|
629
|
+
releaseWalkthroughUrl: z13.string().nullable()
|
|
505
630
|
});
|
|
506
|
-
var statusUpdateSchema =
|
|
507
|
-
id:
|
|
508
|
-
title:
|
|
509
|
-
startDate:
|
|
510
|
-
endDate:
|
|
511
|
-
content:
|
|
512
|
-
createdAt:
|
|
513
|
-
items:
|
|
514
|
-
});
|
|
515
|
-
var statusUpdateListSchema =
|
|
631
|
+
var statusUpdateSchema = z13.object({
|
|
632
|
+
id: z13.string().uuid(),
|
|
633
|
+
title: z13.string().nullable(),
|
|
634
|
+
startDate: z13.string(),
|
|
635
|
+
endDate: z13.string(),
|
|
636
|
+
content: z13.string(),
|
|
637
|
+
createdAt: z13.string(),
|
|
638
|
+
items: z13.array(statusUpdateItemSchema).optional()
|
|
639
|
+
});
|
|
640
|
+
var statusUpdateListSchema = z13.array(statusUpdateSchema);
|
|
641
|
+
// ../../packages/shared/src/schemas/variant.ts
|
|
642
|
+
import { z as z14 } from "zod";
|
|
643
|
+
var variantSchema = z14.object({
|
|
644
|
+
id: z14.string().uuid(),
|
|
645
|
+
presentationId: z14.string().uuid(),
|
|
646
|
+
name: z14.string(),
|
|
647
|
+
audienceId: z14.string().uuid().nullable(),
|
|
648
|
+
isDefault: z14.boolean(),
|
|
649
|
+
order: z14.number().int(),
|
|
650
|
+
createdAt: z14.string(),
|
|
651
|
+
createdBy: z14.string(),
|
|
652
|
+
updatedAt: z14.string().nullable()
|
|
653
|
+
});
|
|
654
|
+
var createVariantSchema = z14.object({
|
|
655
|
+
name: z14.string().min(1),
|
|
656
|
+
audienceId: z14.string().uuid().nullable().optional()
|
|
657
|
+
});
|
|
658
|
+
var updateVariantSchema = z14.object({
|
|
659
|
+
name: z14.string().min(1).optional(),
|
|
660
|
+
audienceId: z14.string().uuid().nullable().optional()
|
|
661
|
+
});
|
|
662
|
+
var variantListSchema = z14.array(variantSchema);
|
|
516
663
|
// src/tools/index.ts
|
|
517
|
-
import { z as
|
|
664
|
+
import { z as z15 } from "zod";
|
|
518
665
|
|
|
519
666
|
// src/auth.ts
|
|
520
667
|
function getCredentials() {
|
|
@@ -1050,6 +1197,121 @@ class ApiClient {
|
|
|
1050
1197
|
async deleteExport(id) {
|
|
1051
1198
|
await this.request(`/v1/exports/${id}`, { method: "DELETE" });
|
|
1052
1199
|
}
|
|
1200
|
+
async listPresentations() {
|
|
1201
|
+
const response = await this.request("/v1/presentations");
|
|
1202
|
+
return { items: response.data, total: response.data.length };
|
|
1203
|
+
}
|
|
1204
|
+
async getPresentation(id) {
|
|
1205
|
+
const response = await this.request(`/v1/presentations/${id}`);
|
|
1206
|
+
return response.data;
|
|
1207
|
+
}
|
|
1208
|
+
async createPresentation(data) {
|
|
1209
|
+
const response = await this.request("/v1/presentations", {
|
|
1210
|
+
method: "POST",
|
|
1211
|
+
body: JSON.stringify(data)
|
|
1212
|
+
});
|
|
1213
|
+
return response.data;
|
|
1214
|
+
}
|
|
1215
|
+
async updatePresentation(id, data) {
|
|
1216
|
+
const response = await this.request(`/v1/presentations/${id}`, {
|
|
1217
|
+
method: "PATCH",
|
|
1218
|
+
body: JSON.stringify(data)
|
|
1219
|
+
});
|
|
1220
|
+
return response.data;
|
|
1221
|
+
}
|
|
1222
|
+
async deletePresentation(id) {
|
|
1223
|
+
await this.request(`/v1/presentations/${id}`, { method: "DELETE" });
|
|
1224
|
+
}
|
|
1225
|
+
async reorderPresentations(items) {
|
|
1226
|
+
await this.request("/v1/presentations/reorder", {
|
|
1227
|
+
method: "POST",
|
|
1228
|
+
body: JSON.stringify({ items })
|
|
1229
|
+
});
|
|
1230
|
+
}
|
|
1231
|
+
async listVariants(presentationId) {
|
|
1232
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants`);
|
|
1233
|
+
return { items: response.data, total: response.data.length };
|
|
1234
|
+
}
|
|
1235
|
+
async getVariant(presentationId, variantId) {
|
|
1236
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}`);
|
|
1237
|
+
return response.data;
|
|
1238
|
+
}
|
|
1239
|
+
async createVariant(presentationId, data) {
|
|
1240
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants`, {
|
|
1241
|
+
method: "POST",
|
|
1242
|
+
body: JSON.stringify(data)
|
|
1243
|
+
});
|
|
1244
|
+
return response.data;
|
|
1245
|
+
}
|
|
1246
|
+
async updateVariant(presentationId, variantId, data) {
|
|
1247
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}`, {
|
|
1248
|
+
method: "PATCH",
|
|
1249
|
+
body: JSON.stringify(data)
|
|
1250
|
+
});
|
|
1251
|
+
return response.data;
|
|
1252
|
+
}
|
|
1253
|
+
async deleteVariant(presentationId, variantId) {
|
|
1254
|
+
await this.request(`/v1/presentations/${presentationId}/variants/${variantId}`, {
|
|
1255
|
+
method: "DELETE"
|
|
1256
|
+
});
|
|
1257
|
+
}
|
|
1258
|
+
async reorderVariants(presentationId, items) {
|
|
1259
|
+
await this.request(`/v1/presentations/${presentationId}/variants/reorder`, {
|
|
1260
|
+
method: "POST",
|
|
1261
|
+
body: JSON.stringify({ items })
|
|
1262
|
+
});
|
|
1263
|
+
}
|
|
1264
|
+
async cloneVariant(presentationId, variantId) {
|
|
1265
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/clone`, { method: "POST" });
|
|
1266
|
+
return response.data;
|
|
1267
|
+
}
|
|
1268
|
+
async setDefaultVariant(presentationId, variantId) {
|
|
1269
|
+
await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/set-default`, {
|
|
1270
|
+
method: "POST"
|
|
1271
|
+
});
|
|
1272
|
+
}
|
|
1273
|
+
async listSlides(presentationId, variantId) {
|
|
1274
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides`);
|
|
1275
|
+
return { items: response.data, total: response.data.length };
|
|
1276
|
+
}
|
|
1277
|
+
async getSlide(presentationId, variantId, slideId) {
|
|
1278
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/${slideId}`);
|
|
1279
|
+
return response.data;
|
|
1280
|
+
}
|
|
1281
|
+
async createSlide(presentationId, variantId, data) {
|
|
1282
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides`, {
|
|
1283
|
+
method: "POST",
|
|
1284
|
+
body: JSON.stringify(data)
|
|
1285
|
+
});
|
|
1286
|
+
return response.data;
|
|
1287
|
+
}
|
|
1288
|
+
async updateSlide(presentationId, variantId, slideId, data) {
|
|
1289
|
+
const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/${slideId}`, {
|
|
1290
|
+
method: "PATCH",
|
|
1291
|
+
body: JSON.stringify(data)
|
|
1292
|
+
});
|
|
1293
|
+
return response.data;
|
|
1294
|
+
}
|
|
1295
|
+
async deleteSlide(presentationId, variantId, slideId) {
|
|
1296
|
+
await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/${slideId}`, { method: "DELETE" });
|
|
1297
|
+
}
|
|
1298
|
+
async reorderSlides(presentationId, variantId, items) {
|
|
1299
|
+
await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/reorder`, {
|
|
1300
|
+
method: "POST",
|
|
1301
|
+
body: JSON.stringify({ items })
|
|
1302
|
+
});
|
|
1303
|
+
}
|
|
1304
|
+
async getVariantPresentationId(variantId) {
|
|
1305
|
+
const presentations = await this.listPresentations();
|
|
1306
|
+
for (const presentation2 of presentations.items) {
|
|
1307
|
+
const variants = await this.listVariants(presentation2.id);
|
|
1308
|
+
const found = variants.items.find((v) => v.id === variantId);
|
|
1309
|
+
if (found) {
|
|
1310
|
+
return presentation2.id;
|
|
1311
|
+
}
|
|
1312
|
+
}
|
|
1313
|
+
return null;
|
|
1314
|
+
}
|
|
1053
1315
|
}
|
|
1054
1316
|
var client = null;
|
|
1055
1317
|
function getApiClient() {
|
|
@@ -1139,6 +1401,26 @@ function registerAllTools(server) {
|
|
|
1139
1401
|
registerCreateExport(server);
|
|
1140
1402
|
registerUpdateExport(server);
|
|
1141
1403
|
registerDeleteExport(server);
|
|
1404
|
+
registerListPresentations(server);
|
|
1405
|
+
registerGetPresentation(server);
|
|
1406
|
+
registerCreatePresentation(server);
|
|
1407
|
+
registerUpdatePresentation(server);
|
|
1408
|
+
registerDeletePresentation(server);
|
|
1409
|
+
registerReorderPresentations(server);
|
|
1410
|
+
registerListVariants(server);
|
|
1411
|
+
registerGetVariant(server);
|
|
1412
|
+
registerCreateVariant(server);
|
|
1413
|
+
registerUpdateVariant(server);
|
|
1414
|
+
registerDeleteVariant(server);
|
|
1415
|
+
registerReorderVariants(server);
|
|
1416
|
+
registerCloneVariant(server);
|
|
1417
|
+
registerSetDefaultVariant(server);
|
|
1418
|
+
registerListSlides(server);
|
|
1419
|
+
registerGetSlide(server);
|
|
1420
|
+
registerCreateSlide(server);
|
|
1421
|
+
registerUpdateSlide(server);
|
|
1422
|
+
registerDeleteSlide(server);
|
|
1423
|
+
registerReorderSlides(server);
|
|
1142
1424
|
}
|
|
1143
1425
|
function registerGetWorkflows(server) {
|
|
1144
1426
|
server.registerTool("get_workflows", {
|
|
@@ -1161,13 +1443,13 @@ function registerSearchRoadmaps(server) {
|
|
|
1161
1443
|
server.registerTool("search_roadmaps", {
|
|
1162
1444
|
description: "Search for roadmap items by title, status, or horizon. Returns a list of matching roadmap items with basic info.",
|
|
1163
1445
|
inputSchema: {
|
|
1164
|
-
query:
|
|
1446
|
+
query: z15.string().optional().describe("Search query to match against title or description"),
|
|
1165
1447
|
status: roadmapStatusSchema.optional().describe("Filter by status"),
|
|
1166
1448
|
horizon: horizonSchema.optional().describe("Filter by planning horizon"),
|
|
1167
|
-
phase:
|
|
1168
|
-
phaseStep:
|
|
1169
|
-
limit:
|
|
1170
|
-
offset:
|
|
1449
|
+
phase: z15.string().optional().describe("Filter by phase"),
|
|
1450
|
+
phaseStep: z15.string().optional().describe("Filter by phase step"),
|
|
1451
|
+
limit: z15.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
|
|
1452
|
+
offset: z15.number().int().min(0).optional().describe("Number of items to skip (default 0)")
|
|
1171
1453
|
}
|
|
1172
1454
|
}, async ({
|
|
1173
1455
|
query,
|
|
@@ -1218,7 +1500,7 @@ function registerGetRoadmap(server) {
|
|
|
1218
1500
|
server.registerTool("get_roadmap", {
|
|
1219
1501
|
description: "Get full details of a roadmap item including PRD, wireframes, brainstorm media, linked features, epics, and stories.",
|
|
1220
1502
|
inputSchema: {
|
|
1221
|
-
id:
|
|
1503
|
+
id: z15.string().describe("The UUID of the roadmap item")
|
|
1222
1504
|
}
|
|
1223
1505
|
}, async ({ id }) => {
|
|
1224
1506
|
const client2 = getApiClient();
|
|
@@ -1272,7 +1554,7 @@ function registerSearchFeatures(server) {
|
|
|
1272
1554
|
server.registerTool("search_features", {
|
|
1273
1555
|
description: "Search for features and feature areas by name. Returns a list of matching features with basic info.",
|
|
1274
1556
|
inputSchema: {
|
|
1275
|
-
query:
|
|
1557
|
+
query: z15.string().optional().describe("Search query to match against name"),
|
|
1276
1558
|
type: featureTypeSchema.optional().describe("Filter by type (feature or area)")
|
|
1277
1559
|
}
|
|
1278
1560
|
}, async ({ query, type }) => {
|
|
@@ -1304,7 +1586,7 @@ function registerGetFeature(server) {
|
|
|
1304
1586
|
server.registerTool("get_feature", {
|
|
1305
1587
|
description: "Get full details of a feature including outcomes, child features, and linked roadmap items.",
|
|
1306
1588
|
inputSchema: {
|
|
1307
|
-
id:
|
|
1589
|
+
id: z15.string().describe("The UUID of the feature")
|
|
1308
1590
|
}
|
|
1309
1591
|
}, async ({ id }) => {
|
|
1310
1592
|
const client2 = getApiClient();
|
|
@@ -1343,7 +1625,7 @@ function registerSearchIdeas(server) {
|
|
|
1343
1625
|
server.registerTool("search_ideas", {
|
|
1344
1626
|
description: "Search for ideas by title or status. Returns a list of matching ideas with basic info.",
|
|
1345
1627
|
inputSchema: {
|
|
1346
|
-
query:
|
|
1628
|
+
query: z15.string().optional().describe("Search query to match against title or description"),
|
|
1347
1629
|
status: ideaStatusSchema.optional().describe("Filter by status")
|
|
1348
1630
|
}
|
|
1349
1631
|
}, async ({ query, status }) => {
|
|
@@ -1443,9 +1725,9 @@ function registerCaptureIdea(server) {
|
|
|
1443
1725
|
server.registerTool("capture_idea", {
|
|
1444
1726
|
description: "Quickly capture a new idea. Ideas are suggestions that can later be reviewed and potentially converted to roadmap items.",
|
|
1445
1727
|
inputSchema: {
|
|
1446
|
-
title:
|
|
1447
|
-
description:
|
|
1448
|
-
source:
|
|
1728
|
+
title: z15.string().describe("Title of the idea"),
|
|
1729
|
+
description: z15.string().optional().describe("Detailed description of the idea"),
|
|
1730
|
+
source: z15.string().optional().describe('Source of the idea (defaults to "claude-code")')
|
|
1449
1731
|
}
|
|
1450
1732
|
}, async ({
|
|
1451
1733
|
title,
|
|
@@ -1482,16 +1764,16 @@ function registerCreateRoadmapItem(server) {
|
|
|
1482
1764
|
server.registerTool("create_roadmap_item", {
|
|
1483
1765
|
description: "Create a new roadmap item. Use this to add planned work to the roadmap.",
|
|
1484
1766
|
inputSchema: {
|
|
1485
|
-
title:
|
|
1767
|
+
title: z15.string().describe("Title of the roadmap item"),
|
|
1486
1768
|
status: roadmapStatusSchema.optional().describe('Status (defaults to "not_started")'),
|
|
1487
1769
|
horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
|
|
1488
|
-
phase:
|
|
1489
|
-
phaseStep:
|
|
1490
|
-
initiativeId:
|
|
1770
|
+
phase: z15.string().optional().describe('Initial phase key (e.g., "brainstorm", "prd", "design")'),
|
|
1771
|
+
phaseStep: z15.string().optional().describe('Initial step within phase (e.g., "not_started", "drafting")'),
|
|
1772
|
+
initiativeId: z15.string().optional().describe("UUID of initiative to link this item to on creation"),
|
|
1491
1773
|
dateGranularity: dateGranularitySchema2.optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
|
|
1492
|
-
dateValue:
|
|
1774
|
+
dateValue: z15.string().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
|
|
1493
1775
|
targetGranularity: dateGranularitySchema2.optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
|
|
1494
|
-
targetValue:
|
|
1776
|
+
targetValue: z15.string().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
|
|
1495
1777
|
}
|
|
1496
1778
|
}, async ({
|
|
1497
1779
|
title,
|
|
@@ -1553,30 +1835,30 @@ function registerCreateRoadmapItem(server) {
|
|
|
1553
1835
|
};
|
|
1554
1836
|
});
|
|
1555
1837
|
}
|
|
1556
|
-
var effortSizeSchema =
|
|
1838
|
+
var effortSizeSchema = z15.enum(["xs", "s", "m", "l", "xl"]);
|
|
1557
1839
|
function registerUpdateRoadmapItem(server) {
|
|
1558
1840
|
server.registerTool("update_roadmap_item", {
|
|
1559
1841
|
description: "Update an existing roadmap item. Can update title, status, horizon, value, effort, order, prompt, initiative link, target date, phase, phaseStep, or brainstorm notes.",
|
|
1560
1842
|
inputSchema: {
|
|
1561
|
-
id:
|
|
1562
|
-
title:
|
|
1843
|
+
id: z15.string().describe("The UUID of the roadmap item to update"),
|
|
1844
|
+
title: z15.string().optional().describe("New title"),
|
|
1563
1845
|
status: roadmapStatusSchema.optional().describe("New status"),
|
|
1564
1846
|
horizon: horizonSchema.optional().describe("New planning horizon"),
|
|
1565
|
-
phase:
|
|
1566
|
-
phaseStep:
|
|
1567
|
-
value:
|
|
1847
|
+
phase: z15.string().optional().describe('Current phase key (e.g., "prd", "design", "build")'),
|
|
1848
|
+
phaseStep: z15.string().optional().describe('Current step within phase (e.g., "drafting", "needs_review", "approved")'),
|
|
1849
|
+
value: z15.number().int().min(1).max(3).nullable().optional().describe("Value rating (1-3 stars, where 3 is highest value)"),
|
|
1568
1850
|
effort: effortSizeSchema.nullable().optional().describe("Effort estimate (xs=extra small, s=small, m=medium, l=large, xl=extra large)"),
|
|
1569
|
-
order:
|
|
1570
|
-
initiativeId:
|
|
1571
|
-
designDescription:
|
|
1572
|
-
planDescription:
|
|
1573
|
-
buildDescription:
|
|
1574
|
-
releaseDescription:
|
|
1575
|
-
prompt:
|
|
1851
|
+
order: z15.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)"),
|
|
1852
|
+
initiativeId: z15.string().nullable().optional().describe("UUID to link item to initiative, or null to unlink from any initiative"),
|
|
1853
|
+
designDescription: z15.string().nullable().optional().describe("Description for the Design phase"),
|
|
1854
|
+
planDescription: z15.string().nullable().optional().describe("Description for the Planning phase"),
|
|
1855
|
+
buildDescription: z15.string().nullable().optional().describe("Description for the Build phase"),
|
|
1856
|
+
releaseDescription: z15.string().nullable().optional().describe("Description for the Release phase"),
|
|
1857
|
+
prompt: z15.string().nullable().optional().describe("Build prompt for the roadmap item"),
|
|
1576
1858
|
dateGranularity: dateGranularitySchema2.nullable().optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
|
|
1577
|
-
dateValue:
|
|
1859
|
+
dateValue: z15.string().nullable().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
|
|
1578
1860
|
targetGranularity: dateGranularitySchema2.nullable().optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
|
|
1579
|
-
targetValue:
|
|
1861
|
+
targetValue: z15.string().nullable().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
|
|
1580
1862
|
}
|
|
1581
1863
|
}, async ({
|
|
1582
1864
|
id,
|
|
@@ -1687,12 +1969,12 @@ function registerAddFeature(server) {
|
|
|
1687
1969
|
server.registerTool("add_feature", {
|
|
1688
1970
|
description: "Create a new feature with optional outcomes. Features represent capabilities or functionality areas.",
|
|
1689
1971
|
inputSchema: {
|
|
1690
|
-
name:
|
|
1691
|
-
description:
|
|
1972
|
+
name: z15.string().describe("Name of the feature"),
|
|
1973
|
+
description: z15.string().optional().describe("Description of the feature"),
|
|
1692
1974
|
type: featureTypeSchema.optional().describe('Type - "feature" for specific functionality, "area" for grouping (defaults to "feature")'),
|
|
1693
|
-
parentId:
|
|
1694
|
-
outcomes:
|
|
1695
|
-
linkToRoadmapId:
|
|
1975
|
+
parentId: z15.string().optional().describe("UUID of parent feature/area to nest under"),
|
|
1976
|
+
outcomes: z15.array(z15.string()).optional().describe("List of expected outcomes for this feature"),
|
|
1977
|
+
linkToRoadmapId: z15.string().optional().describe("UUID of roadmap item to link this feature to")
|
|
1696
1978
|
}
|
|
1697
1979
|
}, async ({
|
|
1698
1980
|
name,
|
|
@@ -1739,10 +2021,10 @@ function registerSavePrd(server) {
|
|
|
1739
2021
|
server.registerTool("save_prd", {
|
|
1740
2022
|
description: "Save or update the PRD (Product Requirements Document) content for a roadmap item. Content should be markdown.",
|
|
1741
2023
|
inputSchema: {
|
|
1742
|
-
roadmapId:
|
|
1743
|
-
what:
|
|
1744
|
-
why:
|
|
1745
|
-
outcomes:
|
|
2024
|
+
roadmapId: z15.string().describe("The UUID of the roadmap item"),
|
|
2025
|
+
what: z15.string().nullable().describe("What is being built - the feature description"),
|
|
2026
|
+
why: z15.string().nullable().describe("Why this is being built - the business justification"),
|
|
2027
|
+
outcomes: z15.array(z15.string()).optional().describe("List of expected outcomes/success criteria")
|
|
1746
2028
|
}
|
|
1747
2029
|
}, async ({
|
|
1748
2030
|
roadmapId,
|
|
@@ -1780,8 +2062,8 @@ function registerUpdateBrainstormNotes(server) {
|
|
|
1780
2062
|
server.registerTool("update_brainstorm_notes", {
|
|
1781
2063
|
description: "Update the brainstorm notes for a roadmap item. Use this to capture ideas, questions, and research notes.",
|
|
1782
2064
|
inputSchema: {
|
|
1783
|
-
roadmapId:
|
|
1784
|
-
notes:
|
|
2065
|
+
roadmapId: z15.string().describe("The UUID of the roadmap item"),
|
|
2066
|
+
notes: z15.string().describe("The brainstorm notes content")
|
|
1785
2067
|
}
|
|
1786
2068
|
}, async ({ roadmapId, notes }) => {
|
|
1787
2069
|
const client2 = getApiClient();
|
|
@@ -1810,7 +2092,7 @@ function registerDeleteRoadmapItem(server) {
|
|
|
1810
2092
|
server.registerTool("delete_roadmap_item", {
|
|
1811
2093
|
description: "Delete a roadmap item. This is a soft delete - the item can potentially be recovered.",
|
|
1812
2094
|
inputSchema: {
|
|
1813
|
-
id:
|
|
2095
|
+
id: z15.string().describe("The UUID of the roadmap item to delete")
|
|
1814
2096
|
}
|
|
1815
2097
|
}, async ({ id }) => {
|
|
1816
2098
|
const client2 = getApiClient();
|
|
@@ -1832,9 +2114,9 @@ function registerReorderRoadmaps(server) {
|
|
|
1832
2114
|
server.registerTool("reorder_roadmaps", {
|
|
1833
2115
|
description: "Bulk reorder roadmap items by setting their order values. Use this to prioritize and organize the roadmap. Lower order values appear first.",
|
|
1834
2116
|
inputSchema: {
|
|
1835
|
-
items:
|
|
1836
|
-
id:
|
|
1837
|
-
order:
|
|
2117
|
+
items: z15.array(z15.object({
|
|
2118
|
+
id: z15.string().describe("The UUID of the roadmap item"),
|
|
2119
|
+
order: z15.number().int().min(0).describe("The new order value (0-based, lower = higher priority)")
|
|
1838
2120
|
})).describe("Array of roadmap items with their new order values")
|
|
1839
2121
|
}
|
|
1840
2122
|
}, async ({ items }) => {
|
|
@@ -1858,10 +2140,10 @@ function registerUpdateFeature(server) {
|
|
|
1858
2140
|
server.registerTool("update_feature", {
|
|
1859
2141
|
description: "Update an existing feature. Can update name, type, or parent.",
|
|
1860
2142
|
inputSchema: {
|
|
1861
|
-
id:
|
|
1862
|
-
name:
|
|
2143
|
+
id: z15.string().describe("The UUID of the feature to update"),
|
|
2144
|
+
name: z15.string().optional().describe("New name for the feature"),
|
|
1863
2145
|
type: featureTypeSchema.optional().describe('New type - "feature" or "area"'),
|
|
1864
|
-
parentId:
|
|
2146
|
+
parentId: z15.string().nullable().optional().describe("New parent feature/area UUID, or null to move to root")
|
|
1865
2147
|
}
|
|
1866
2148
|
}, async ({
|
|
1867
2149
|
id,
|
|
@@ -1900,7 +2182,7 @@ function registerDeleteFeature(server) {
|
|
|
1900
2182
|
server.registerTool("delete_feature", {
|
|
1901
2183
|
description: "Delete a feature. This is a soft delete that also deletes all child features.",
|
|
1902
2184
|
inputSchema: {
|
|
1903
|
-
id:
|
|
2185
|
+
id: z15.string().describe("The UUID of the feature to delete")
|
|
1904
2186
|
}
|
|
1905
2187
|
}, async ({ id }) => {
|
|
1906
2188
|
const client2 = getApiClient();
|
|
@@ -1922,7 +2204,7 @@ function registerGetIdea(server) {
|
|
|
1922
2204
|
server.registerTool("get_idea", {
|
|
1923
2205
|
description: "Get full details of a single idea by ID.",
|
|
1924
2206
|
inputSchema: {
|
|
1925
|
-
id:
|
|
2207
|
+
id: z15.string().describe("The UUID of the idea")
|
|
1926
2208
|
}
|
|
1927
2209
|
}, async ({ id }) => {
|
|
1928
2210
|
const client2 = getApiClient();
|
|
@@ -1951,12 +2233,12 @@ function registerUpdateIdea(server) {
|
|
|
1951
2233
|
server.registerTool("update_idea", {
|
|
1952
2234
|
description: "Update an existing idea. Can update title, description, status, value, or effort.",
|
|
1953
2235
|
inputSchema: {
|
|
1954
|
-
id:
|
|
1955
|
-
title:
|
|
1956
|
-
description:
|
|
2236
|
+
id: z15.string().describe("The UUID of the idea to update"),
|
|
2237
|
+
title: z15.string().optional().describe("New title"),
|
|
2238
|
+
description: z15.string().nullable().optional().describe("New description"),
|
|
1957
2239
|
status: ideaStatusSchema.optional().describe("New status"),
|
|
1958
|
-
value:
|
|
1959
|
-
effort:
|
|
2240
|
+
value: z15.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated value"),
|
|
2241
|
+
effort: z15.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated effort")
|
|
1960
2242
|
}
|
|
1961
2243
|
}, async ({
|
|
1962
2244
|
id,
|
|
@@ -2003,7 +2285,7 @@ function registerDeleteIdea(server) {
|
|
|
2003
2285
|
server.registerTool("delete_idea", {
|
|
2004
2286
|
description: "Delete an idea. This is a soft delete.",
|
|
2005
2287
|
inputSchema: {
|
|
2006
|
-
id:
|
|
2288
|
+
id: z15.string().describe("The UUID of the idea to delete")
|
|
2007
2289
|
}
|
|
2008
2290
|
}, async ({ id }) => {
|
|
2009
2291
|
const client2 = getApiClient();
|
|
@@ -2042,8 +2324,8 @@ function registerUpdateStrategy(server) {
|
|
|
2042
2324
|
server.registerTool("update_strategy", {
|
|
2043
2325
|
description: "Update the organization strategy. Can update vision, mission, or both. Use this to set or refine the high-level direction.",
|
|
2044
2326
|
inputSchema: {
|
|
2045
|
-
vision:
|
|
2046
|
-
mission:
|
|
2327
|
+
vision: z15.string().nullable().optional().describe("The vision statement - where the product is headed"),
|
|
2328
|
+
mission: z15.string().nullable().optional().describe("The mission statement - why the product exists")
|
|
2047
2329
|
}
|
|
2048
2330
|
}, async ({ vision, mission }) => {
|
|
2049
2331
|
const client2 = getApiClient();
|
|
@@ -2091,8 +2373,8 @@ function registerCreateScenario(server) {
|
|
|
2091
2373
|
server.registerTool("create_scenario", {
|
|
2092
2374
|
description: "Create a new user scenario. Scenarios describe user workflows and how they accomplish goals.",
|
|
2093
2375
|
inputSchema: {
|
|
2094
|
-
title:
|
|
2095
|
-
description:
|
|
2376
|
+
title: z15.string().describe('Title of the scenario (e.g., "User creates their first roadmap")'),
|
|
2377
|
+
description: z15.string().nullable().optional().describe("Detailed description of the scenario workflow")
|
|
2096
2378
|
}
|
|
2097
2379
|
}, async ({ title, description }) => {
|
|
2098
2380
|
const client2 = getApiClient();
|
|
@@ -2121,9 +2403,9 @@ function registerUpdateScenario(server) {
|
|
|
2121
2403
|
server.registerTool("update_scenario", {
|
|
2122
2404
|
description: "Update an existing scenario.",
|
|
2123
2405
|
inputSchema: {
|
|
2124
|
-
id:
|
|
2125
|
-
title:
|
|
2126
|
-
description:
|
|
2406
|
+
id: z15.string().describe("The UUID of the scenario to update"),
|
|
2407
|
+
title: z15.string().optional().describe("New title"),
|
|
2408
|
+
description: z15.string().nullable().optional().describe("New description")
|
|
2127
2409
|
}
|
|
2128
2410
|
}, async ({
|
|
2129
2411
|
id,
|
|
@@ -2158,7 +2440,7 @@ function registerDeleteScenario(server) {
|
|
|
2158
2440
|
server.registerTool("delete_scenario", {
|
|
2159
2441
|
description: "Delete a scenario. This is a soft delete.",
|
|
2160
2442
|
inputSchema: {
|
|
2161
|
-
id:
|
|
2443
|
+
id: z15.string().describe("The UUID of the scenario to delete")
|
|
2162
2444
|
}
|
|
2163
2445
|
}, async ({ id }) => {
|
|
2164
2446
|
const client2 = getApiClient();
|
|
@@ -2173,7 +2455,7 @@ function registerDeleteScenario(server) {
|
|
|
2173
2455
|
};
|
|
2174
2456
|
});
|
|
2175
2457
|
}
|
|
2176
|
-
var productTypeSchema2 =
|
|
2458
|
+
var productTypeSchema2 = z15.enum([
|
|
2177
2459
|
"brand",
|
|
2178
2460
|
"product",
|
|
2179
2461
|
"app",
|
|
@@ -2186,8 +2468,8 @@ function registerCreateProduct(server) {
|
|
|
2186
2468
|
description: "Create a new product, app, brand, or service. Products represent what the organization builds and offers.",
|
|
2187
2469
|
inputSchema: {
|
|
2188
2470
|
type: productTypeSchema2.describe("Type of product"),
|
|
2189
|
-
name:
|
|
2190
|
-
parentId:
|
|
2471
|
+
name: z15.string().describe("Name of the product"),
|
|
2472
|
+
parentId: z15.string().nullable().optional().describe("UUID of parent product to nest under")
|
|
2191
2473
|
}
|
|
2192
2474
|
}, async ({
|
|
2193
2475
|
type,
|
|
@@ -2222,9 +2504,9 @@ function registerUpdateProduct(server) {
|
|
|
2222
2504
|
server.registerTool("update_product", {
|
|
2223
2505
|
description: "Update an existing product.",
|
|
2224
2506
|
inputSchema: {
|
|
2225
|
-
id:
|
|
2226
|
-
name:
|
|
2227
|
-
parentId:
|
|
2507
|
+
id: z15.string().describe("The UUID of the product to update"),
|
|
2508
|
+
name: z15.string().optional().describe("New name"),
|
|
2509
|
+
parentId: z15.string().nullable().optional().describe("New parent product UUID, or null to move to root")
|
|
2228
2510
|
}
|
|
2229
2511
|
}, async ({ id, name, parentId }) => {
|
|
2230
2512
|
const client2 = getApiClient();
|
|
@@ -2256,7 +2538,7 @@ function registerDeleteProduct(server) {
|
|
|
2256
2538
|
server.registerTool("delete_product", {
|
|
2257
2539
|
description: "Delete a product. This is a soft delete that also deletes all child products.",
|
|
2258
2540
|
inputSchema: {
|
|
2259
|
-
id:
|
|
2541
|
+
id: z15.string().describe("The UUID of the product to delete")
|
|
2260
2542
|
}
|
|
2261
2543
|
}, async ({ id }) => {
|
|
2262
2544
|
const client2 = getApiClient();
|
|
@@ -2279,7 +2561,7 @@ function registerGetProduct(server) {
|
|
|
2279
2561
|
server.registerTool("get_product", {
|
|
2280
2562
|
description: "Get full details of a product by ID, including its documentation (design system and ADRs).",
|
|
2281
2563
|
inputSchema: {
|
|
2282
|
-
id:
|
|
2564
|
+
id: z15.string().describe("The UUID of the product")
|
|
2283
2565
|
}
|
|
2284
2566
|
}, async ({ id }) => {
|
|
2285
2567
|
const client2 = getApiClient();
|
|
@@ -2316,7 +2598,7 @@ function registerSearchProducts(server) {
|
|
|
2316
2598
|
server.registerTool("search_products", {
|
|
2317
2599
|
description: "Search for products by name. Returns a list of matching products with basic info.",
|
|
2318
2600
|
inputSchema: {
|
|
2319
|
-
query:
|
|
2601
|
+
query: z15.string().optional().describe("Search query to match against product name"),
|
|
2320
2602
|
type: productTypeSchema2.optional().describe("Filter by product type")
|
|
2321
2603
|
}
|
|
2322
2604
|
}, async ({ query, type }) => {
|
|
@@ -2351,7 +2633,7 @@ function registerGetProductDocumentation(server) {
|
|
|
2351
2633
|
server.registerTool("get_product_documentation", {
|
|
2352
2634
|
description: "Get the documentation (design system and ADRs) for a product. Use this to read existing documentation before updating.",
|
|
2353
2635
|
inputSchema: {
|
|
2354
|
-
productId:
|
|
2636
|
+
productId: z15.string().describe("The UUID of the product")
|
|
2355
2637
|
}
|
|
2356
2638
|
}, async ({ productId }) => {
|
|
2357
2639
|
const client2 = getApiClient();
|
|
@@ -2379,9 +2661,9 @@ function registerUpdateProductDocumentation(server) {
|
|
|
2379
2661
|
server.registerTool("update_product_documentation", {
|
|
2380
2662
|
description: "Update the documentation for a product. Use this to keep design system and ADRs up to date. Creates documentation if it does not exist.",
|
|
2381
2663
|
inputSchema: {
|
|
2382
|
-
productId:
|
|
2383
|
-
designSystem:
|
|
2384
|
-
adrs:
|
|
2664
|
+
productId: z15.string().describe("The UUID of the product"),
|
|
2665
|
+
designSystem: z15.string().nullable().optional().describe("Design system documentation - colors, typography, spacing, components. Pass null to clear."),
|
|
2666
|
+
adrs: z15.string().nullable().optional().describe("Architecture Decision Records - document key technical decisions. Pass null to clear.")
|
|
2385
2667
|
}
|
|
2386
2668
|
}, async ({
|
|
2387
2669
|
productId,
|
|
@@ -2418,8 +2700,8 @@ function registerCreateAudience(server) {
|
|
|
2418
2700
|
server.registerTool("create_audience", {
|
|
2419
2701
|
description: "Create a new audience member. Audiences represent who the product serves.",
|
|
2420
2702
|
inputSchema: {
|
|
2421
|
-
name:
|
|
2422
|
-
description:
|
|
2703
|
+
name: z15.string().describe('Name of the audience (e.g., "Product Manager", "End User")'),
|
|
2704
|
+
description: z15.string().nullable().optional().describe("Description of the audience")
|
|
2423
2705
|
}
|
|
2424
2706
|
}, async ({ name, description }) => {
|
|
2425
2707
|
const client2 = getApiClient();
|
|
@@ -2448,9 +2730,9 @@ function registerUpdateAudience(server) {
|
|
|
2448
2730
|
server.registerTool("update_audience", {
|
|
2449
2731
|
description: "Update an existing audience member.",
|
|
2450
2732
|
inputSchema: {
|
|
2451
|
-
id:
|
|
2452
|
-
name:
|
|
2453
|
-
description:
|
|
2733
|
+
id: z15.string().describe("The UUID of the audience to update"),
|
|
2734
|
+
name: z15.string().optional().describe("New name"),
|
|
2735
|
+
description: z15.string().nullable().optional().describe("New description")
|
|
2454
2736
|
}
|
|
2455
2737
|
}, async ({
|
|
2456
2738
|
id,
|
|
@@ -2485,7 +2767,7 @@ function registerDeleteAudience(server) {
|
|
|
2485
2767
|
server.registerTool("delete_audience", {
|
|
2486
2768
|
description: "Delete an audience member. This is a soft delete.",
|
|
2487
2769
|
inputSchema: {
|
|
2488
|
-
id:
|
|
2770
|
+
id: z15.string().describe("The UUID of the audience to delete")
|
|
2489
2771
|
}
|
|
2490
2772
|
}, async ({ id }) => {
|
|
2491
2773
|
const client2 = getApiClient();
|
|
@@ -2527,9 +2809,9 @@ function registerGetHistory(server) {
|
|
|
2527
2809
|
server.registerTool("get_history", {
|
|
2528
2810
|
description: "Get raw history events for a date range. Returns full event details including payloads. " + "Use entityType or entityId filters to narrow results. For status reports, prefer " + "get_history_summary to avoid context overflow.",
|
|
2529
2811
|
inputSchema: {
|
|
2530
|
-
startDate:
|
|
2531
|
-
endDate:
|
|
2532
|
-
entityType:
|
|
2812
|
+
startDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
|
|
2813
|
+
endDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format"),
|
|
2814
|
+
entityType: z15.enum([
|
|
2533
2815
|
"roadmap",
|
|
2534
2816
|
"feature",
|
|
2535
2817
|
"idea",
|
|
@@ -2561,8 +2843,8 @@ function registerGetHistorySummary(server) {
|
|
|
2561
2843
|
server.registerTool("get_history_summary", {
|
|
2562
2844
|
description: "Get a summary of history events for a date range. Returns counts by entity type, " + "list of changed entities with titles, and total event count. Use this for status " + "report generation instead of get_history to avoid context overflow.",
|
|
2563
2845
|
inputSchema: {
|
|
2564
|
-
startDate:
|
|
2565
|
-
endDate:
|
|
2846
|
+
startDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
|
|
2847
|
+
endDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format")
|
|
2566
2848
|
}
|
|
2567
2849
|
}, async ({ startDate, endDate }) => {
|
|
2568
2850
|
const client2 = getApiClient();
|
|
@@ -2581,13 +2863,13 @@ function registerCreateStatusUpdate(server) {
|
|
|
2581
2863
|
server.registerTool("create_status_update", {
|
|
2582
2864
|
description: "Create a new status report. Use this after generating the report content from history events.",
|
|
2583
2865
|
inputSchema: {
|
|
2584
|
-
startDate:
|
|
2585
|
-
endDate:
|
|
2586
|
-
content:
|
|
2587
|
-
title:
|
|
2588
|
-
items:
|
|
2589
|
-
roadmapItemId:
|
|
2590
|
-
status:
|
|
2866
|
+
startDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period start date in YYYY-MM-DD format"),
|
|
2867
|
+
endDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period end date in YYYY-MM-DD format"),
|
|
2868
|
+
content: z15.string().describe("The markdown content of the status report"),
|
|
2869
|
+
title: z15.string().optional().describe("Optional title for the report"),
|
|
2870
|
+
items: z15.array(z15.object({
|
|
2871
|
+
roadmapItemId: z15.string().describe("UUID of the roadmap item"),
|
|
2872
|
+
status: z15.string().describe("Status of the item at report creation time")
|
|
2591
2873
|
})).optional().describe("Roadmap items to include in the report snapshot")
|
|
2592
2874
|
}
|
|
2593
2875
|
}, async ({
|
|
@@ -2628,18 +2910,18 @@ function registerSaveStories(server) {
|
|
|
2628
2910
|
server.registerTool("save_stories", {
|
|
2629
2911
|
description: "Save epics and stories for a roadmap item. Replaces all existing epics/stories. Use this to set the complete list of epics and stories for a roadmap.",
|
|
2630
2912
|
inputSchema: {
|
|
2631
|
-
roadmapId:
|
|
2632
|
-
epics:
|
|
2633
|
-
title:
|
|
2634
|
-
description:
|
|
2635
|
-
stories:
|
|
2636
|
-
title:
|
|
2637
|
-
description:
|
|
2913
|
+
roadmapId: z15.string().uuid().describe("The UUID of the roadmap item"),
|
|
2914
|
+
epics: z15.array(z15.object({
|
|
2915
|
+
title: z15.string().min(1).describe("Title of the epic"),
|
|
2916
|
+
description: z15.string().nullable().optional().describe("Description of the epic"),
|
|
2917
|
+
stories: z15.array(z15.object({
|
|
2918
|
+
title: z15.string().min(1).describe("Title of the story"),
|
|
2919
|
+
description: z15.string().nullable().optional().describe("Description of the story")
|
|
2638
2920
|
})).optional().describe("Stories within this epic")
|
|
2639
2921
|
})).optional().describe("List of epics with their nested stories"),
|
|
2640
|
-
stories:
|
|
2641
|
-
title:
|
|
2642
|
-
description:
|
|
2922
|
+
stories: z15.array(z15.object({
|
|
2923
|
+
title: z15.string().min(1).describe("Title of the story"),
|
|
2924
|
+
description: z15.string().nullable().optional().describe("Description of the story")
|
|
2643
2925
|
})).optional().describe("List of standalone stories (not part of any epic)")
|
|
2644
2926
|
}
|
|
2645
2927
|
}, async ({
|
|
@@ -2671,10 +2953,10 @@ function registerUploadWireframe(server) {
|
|
|
2671
2953
|
server.registerTool("upload_wireframe", {
|
|
2672
2954
|
description: "Upload an image to a roadmap item's wireframes. Returns a curl command to execute for the upload, then creates the wireframe record. After running the curl command, the wireframe will be visible in the web app.",
|
|
2673
2955
|
inputSchema: {
|
|
2674
|
-
roadmapId:
|
|
2675
|
-
filePath:
|
|
2676
|
-
description:
|
|
2677
|
-
outcomeIds:
|
|
2956
|
+
roadmapId: z15.string().describe("The UUID of the roadmap item"),
|
|
2957
|
+
filePath: z15.string().describe("Absolute path to the image file on disk"),
|
|
2958
|
+
description: z15.string().optional().describe("Optional description of the wireframe"),
|
|
2959
|
+
outcomeIds: z15.array(z15.string()).optional().describe("Optional array of PRD outcome IDs this wireframe addresses")
|
|
2678
2960
|
}
|
|
2679
2961
|
}, async ({
|
|
2680
2962
|
roadmapId,
|
|
@@ -2728,9 +3010,9 @@ function registerUpdateWireframe(server) {
|
|
|
2728
3010
|
server.registerTool("update_wireframe", {
|
|
2729
3011
|
description: "Update a wireframe's description or outcome tags.",
|
|
2730
3012
|
inputSchema: {
|
|
2731
|
-
id:
|
|
2732
|
-
description:
|
|
2733
|
-
outcomeIds:
|
|
3013
|
+
id: z15.string().describe("The UUID of the wireframe"),
|
|
3014
|
+
description: z15.string().nullable().optional().describe("New description for the wireframe"),
|
|
3015
|
+
outcomeIds: z15.array(z15.string()).optional().describe("Array of PRD outcome IDs this wireframe addresses (replaces existing)")
|
|
2734
3016
|
}
|
|
2735
3017
|
}, async ({
|
|
2736
3018
|
id,
|
|
@@ -2766,7 +3048,7 @@ function registerDeleteWireframe(server) {
|
|
|
2766
3048
|
server.registerTool("delete_wireframe", {
|
|
2767
3049
|
description: "Delete a wireframe (soft delete).",
|
|
2768
3050
|
inputSchema: {
|
|
2769
|
-
id:
|
|
3051
|
+
id: z15.string().describe("The UUID of the wireframe to delete")
|
|
2770
3052
|
}
|
|
2771
3053
|
}, async ({ id }) => {
|
|
2772
3054
|
const client2 = getApiClient();
|
|
@@ -2785,9 +3067,9 @@ function registerUploadBrainstormMedia(server) {
|
|
|
2785
3067
|
server.registerTool("upload_brainstorm_media", {
|
|
2786
3068
|
description: "Upload an image or video to a roadmap item's brainstorming section. Returns a curl command to execute for the upload.",
|
|
2787
3069
|
inputSchema: {
|
|
2788
|
-
roadmapId:
|
|
2789
|
-
filePath:
|
|
2790
|
-
description:
|
|
3070
|
+
roadmapId: z15.string().describe("The UUID of the roadmap item"),
|
|
3071
|
+
filePath: z15.string().describe("Absolute path to the image or video file on disk"),
|
|
3072
|
+
description: z15.string().optional().describe("Optional description of the media")
|
|
2791
3073
|
}
|
|
2792
3074
|
}, async ({
|
|
2793
3075
|
roadmapId,
|
|
@@ -2839,8 +3121,8 @@ function registerUpdateBrainstormMedia(server) {
|
|
|
2839
3121
|
server.registerTool("update_brainstorm_media", {
|
|
2840
3122
|
description: "Update a brainstorm media item's description.",
|
|
2841
3123
|
inputSchema: {
|
|
2842
|
-
id:
|
|
2843
|
-
description:
|
|
3124
|
+
id: z15.string().describe("The UUID of the brainstorm media"),
|
|
3125
|
+
description: z15.string().nullable().describe("New description for the media")
|
|
2844
3126
|
}
|
|
2845
3127
|
}, async ({ id, description }) => {
|
|
2846
3128
|
const client2 = getApiClient();
|
|
@@ -2864,7 +3146,7 @@ function registerDeleteBrainstormMedia(server) {
|
|
|
2864
3146
|
server.registerTool("delete_brainstorm_media", {
|
|
2865
3147
|
description: "Delete a brainstorm media item (soft delete).",
|
|
2866
3148
|
inputSchema: {
|
|
2867
|
-
id:
|
|
3149
|
+
id: z15.string().describe("The UUID of the brainstorm media to delete")
|
|
2868
3150
|
}
|
|
2869
3151
|
}, async ({ id }) => {
|
|
2870
3152
|
const client2 = getApiClient();
|
|
@@ -2883,9 +3165,9 @@ function registerUploadProductDesignMedia(server) {
|
|
|
2883
3165
|
server.registerTool("upload_product_design_media", {
|
|
2884
3166
|
description: "Upload an image or video to a product's design media section. Returns a curl command to execute for the upload.",
|
|
2885
3167
|
inputSchema: {
|
|
2886
|
-
productId:
|
|
2887
|
-
filePath:
|
|
2888
|
-
description:
|
|
3168
|
+
productId: z15.string().describe("The UUID of the product"),
|
|
3169
|
+
filePath: z15.string().describe("Absolute path to the image or video file on disk"),
|
|
3170
|
+
description: z15.string().optional().describe("Optional description of the media")
|
|
2889
3171
|
}
|
|
2890
3172
|
}, async ({
|
|
2891
3173
|
productId,
|
|
@@ -2938,9 +3220,9 @@ function registerUpdateProductDesignMedia(server) {
|
|
|
2938
3220
|
server.registerTool("update_product_design_media", {
|
|
2939
3221
|
description: "Update a product design media item's description.",
|
|
2940
3222
|
inputSchema: {
|
|
2941
|
-
productId:
|
|
2942
|
-
mediaId:
|
|
2943
|
-
description:
|
|
3223
|
+
productId: z15.string().describe("The UUID of the product"),
|
|
3224
|
+
mediaId: z15.string().describe("The UUID of the design media"),
|
|
3225
|
+
description: z15.string().nullable().describe("New description for the media")
|
|
2944
3226
|
}
|
|
2945
3227
|
}, async ({
|
|
2946
3228
|
productId,
|
|
@@ -2968,8 +3250,8 @@ function registerDeleteProductDesignMedia(server) {
|
|
|
2968
3250
|
server.registerTool("delete_product_design_media", {
|
|
2969
3251
|
description: "Delete a product design media item (soft delete).",
|
|
2970
3252
|
inputSchema: {
|
|
2971
|
-
productId:
|
|
2972
|
-
mediaId:
|
|
3253
|
+
productId: z15.string().describe("The UUID of the product"),
|
|
3254
|
+
mediaId: z15.string().describe("The UUID of the design media to delete")
|
|
2973
3255
|
}
|
|
2974
3256
|
}, async ({ productId, mediaId }) => {
|
|
2975
3257
|
const client2 = getApiClient();
|
|
@@ -2991,8 +3273,8 @@ function registerUploadDesignWalkthrough(server) {
|
|
|
2991
3273
|
server.registerTool("upload_design_walkthrough", {
|
|
2992
3274
|
description: "Upload a walkthrough video to a roadmap item's design phase. Returns a curl command to execute for the upload.",
|
|
2993
3275
|
inputSchema: {
|
|
2994
|
-
roadmapId:
|
|
2995
|
-
filePath:
|
|
3276
|
+
roadmapId: z15.string().describe("The UUID of the roadmap item"),
|
|
3277
|
+
filePath: z15.string().describe("Absolute path to the video file on disk")
|
|
2996
3278
|
}
|
|
2997
3279
|
}, async ({ roadmapId, filePath }) => {
|
|
2998
3280
|
const client2 = getApiClient();
|
|
@@ -3034,8 +3316,8 @@ function registerUploadReleaseWalkthrough(server) {
|
|
|
3034
3316
|
server.registerTool("upload_release_walkthrough", {
|
|
3035
3317
|
description: "Upload a walkthrough video to a roadmap item's release phase. Returns a curl command to execute for the upload.",
|
|
3036
3318
|
inputSchema: {
|
|
3037
|
-
roadmapId:
|
|
3038
|
-
filePath:
|
|
3319
|
+
roadmapId: z15.string().describe("The UUID of the roadmap item"),
|
|
3320
|
+
filePath: z15.string().describe("Absolute path to the video file on disk")
|
|
3039
3321
|
}
|
|
3040
3322
|
}, async ({ roadmapId, filePath }) => {
|
|
3041
3323
|
const client2 = getApiClient();
|
|
@@ -3093,9 +3375,9 @@ function registerPublishPrototype(server) {
|
|
|
3093
3375
|
server.registerTool("publish_prototype", {
|
|
3094
3376
|
description: "Publish a local prototype folder to a shareable URL. Uploads all files from the folder and returns a time-limited shareable link.",
|
|
3095
3377
|
inputSchema: {
|
|
3096
|
-
roadmapId:
|
|
3097
|
-
folderPath:
|
|
3098
|
-
entryPoint:
|
|
3378
|
+
roadmapId: z15.string().uuid().describe("The UUID of the roadmap item to attach the prototype to"),
|
|
3379
|
+
folderPath: z15.string().describe("Absolute path to the local mockup folder"),
|
|
3380
|
+
entryPoint: z15.string().default("index.html").describe("Main HTML file to open (defaults to index.html)")
|
|
3099
3381
|
}
|
|
3100
3382
|
}, async ({
|
|
3101
3383
|
roadmapId,
|
|
@@ -3250,15 +3532,15 @@ Expires: ${expiryDate}`
|
|
|
3250
3532
|
};
|
|
3251
3533
|
});
|
|
3252
3534
|
}
|
|
3253
|
-
var dateGranularitySchema2 =
|
|
3535
|
+
var dateGranularitySchema2 = z15.enum(["day", "month", "quarter", "half-year", "year"]);
|
|
3254
3536
|
function registerSearchInitiatives(server) {
|
|
3255
3537
|
server.registerTool("search_initiatives", {
|
|
3256
3538
|
description: "Search for initiatives by title or filter by horizon. Returns a list of matching initiatives with item counts.",
|
|
3257
3539
|
inputSchema: {
|
|
3258
|
-
query:
|
|
3540
|
+
query: z15.string().optional().describe("Search query to match against title or description"),
|
|
3259
3541
|
horizon: horizonSchema.optional().describe("Filter by planning horizon"),
|
|
3260
|
-
limit:
|
|
3261
|
-
offset:
|
|
3542
|
+
limit: z15.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
|
|
3543
|
+
offset: z15.number().int().min(0).optional().describe("Number of items to skip (default 0)")
|
|
3262
3544
|
}
|
|
3263
3545
|
}, async ({
|
|
3264
3546
|
query,
|
|
@@ -3308,7 +3590,7 @@ function registerGetInitiative(server) {
|
|
|
3308
3590
|
server.registerTool("get_initiative", {
|
|
3309
3591
|
description: "Get full details of an initiative including all linked roadmap items.",
|
|
3310
3592
|
inputSchema: {
|
|
3311
|
-
id:
|
|
3593
|
+
id: z15.string().describe("The UUID of the initiative")
|
|
3312
3594
|
}
|
|
3313
3595
|
}, async ({ id }) => {
|
|
3314
3596
|
const client2 = getApiClient();
|
|
@@ -3327,12 +3609,12 @@ function registerCreateInitiative(server) {
|
|
|
3327
3609
|
server.registerTool("create_initiative", {
|
|
3328
3610
|
description: "Create a new initiative. Initiatives group related roadmap items for cross-functional coordination.",
|
|
3329
3611
|
inputSchema: {
|
|
3330
|
-
title:
|
|
3331
|
-
description:
|
|
3612
|
+
title: z15.string().describe("Title of the initiative"),
|
|
3613
|
+
description: z15.string().optional().describe("Description of the initiative (markdown)"),
|
|
3332
3614
|
horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
|
|
3333
3615
|
dateGranularity: dateGranularitySchema2.optional().describe("Target date granularity: day, month, quarter, half-year, or year"),
|
|
3334
|
-
dateValue:
|
|
3335
|
-
targetDate:
|
|
3616
|
+
dateValue: z15.string().optional().describe('Target date value matching granularity (e.g., "2024-Q1", "2024-03")'),
|
|
3617
|
+
targetDate: z15.string().optional().describe("Target date in YYYY-MM-DD format")
|
|
3336
3618
|
}
|
|
3337
3619
|
}, async ({
|
|
3338
3620
|
title,
|
|
@@ -3376,14 +3658,14 @@ function registerUpdateInitiative(server) {
|
|
|
3376
3658
|
server.registerTool("update_initiative", {
|
|
3377
3659
|
description: "Update an existing initiative.",
|
|
3378
3660
|
inputSchema: {
|
|
3379
|
-
id:
|
|
3380
|
-
title:
|
|
3381
|
-
description:
|
|
3661
|
+
id: z15.string().describe("The UUID of the initiative to update"),
|
|
3662
|
+
title: z15.string().optional().describe("New title"),
|
|
3663
|
+
description: z15.string().nullable().optional().describe("New description (null to clear)"),
|
|
3382
3664
|
horizon: horizonSchema.optional().describe("New planning horizon"),
|
|
3383
3665
|
dateGranularity: dateGranularitySchema2.nullable().optional().describe("New target date granularity (null to clear)"),
|
|
3384
|
-
dateValue:
|
|
3385
|
-
targetDate:
|
|
3386
|
-
order:
|
|
3666
|
+
dateValue: z15.string().nullable().optional().describe("New target date value (null to clear)"),
|
|
3667
|
+
targetDate: z15.string().nullable().optional().describe("New target date in YYYY-MM-DD format (null to clear)"),
|
|
3668
|
+
order: z15.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)")
|
|
3387
3669
|
}
|
|
3388
3670
|
}, async ({
|
|
3389
3671
|
id,
|
|
@@ -3438,7 +3720,7 @@ function registerDeleteInitiative(server) {
|
|
|
3438
3720
|
server.registerTool("delete_initiative", {
|
|
3439
3721
|
description: "Delete an initiative. This is a soft delete that also unlinks all roadmap items from the initiative.",
|
|
3440
3722
|
inputSchema: {
|
|
3441
|
-
id:
|
|
3723
|
+
id: z15.string().describe("The UUID of the initiative to delete")
|
|
3442
3724
|
}
|
|
3443
3725
|
}, async ({ id }) => {
|
|
3444
3726
|
const client2 = getApiClient();
|
|
@@ -3457,9 +3739,9 @@ function registerReorderInitiatives(server) {
|
|
|
3457
3739
|
server.registerTool("reorder_initiatives", {
|
|
3458
3740
|
description: "Bulk reorder initiatives by setting their order values. Lower order values appear first.",
|
|
3459
3741
|
inputSchema: {
|
|
3460
|
-
items:
|
|
3461
|
-
id:
|
|
3462
|
-
order:
|
|
3742
|
+
items: z15.array(z15.object({
|
|
3743
|
+
id: z15.string().describe("The UUID of the initiative"),
|
|
3744
|
+
order: z15.number().int().min(0).describe("The new order value (0-based)")
|
|
3463
3745
|
})).describe("Array of initiatives with their new order values")
|
|
3464
3746
|
}
|
|
3465
3747
|
}, async ({ items }) => {
|
|
@@ -3479,12 +3761,12 @@ function registerSearchExports(server) {
|
|
|
3479
3761
|
server.registerTool("search_exports", {
|
|
3480
3762
|
description: "Search for export records by roadmap, external system, or entity. Returns a list of matching exports with pagination.",
|
|
3481
3763
|
inputSchema: {
|
|
3482
|
-
roadmapId:
|
|
3483
|
-
externalSystem:
|
|
3484
|
-
localEntityType:
|
|
3485
|
-
localEntityId:
|
|
3486
|
-
limit:
|
|
3487
|
-
offset:
|
|
3764
|
+
roadmapId: z15.string().uuid().optional().describe("Filter by roadmap item ID"),
|
|
3765
|
+
externalSystem: z15.enum(["linear", "notion", "jira", "github"]).optional().describe("Filter by external system"),
|
|
3766
|
+
localEntityType: z15.enum(["roadmap", "prd", "epic", "story", "design"]).optional().describe("Filter by local entity type"),
|
|
3767
|
+
localEntityId: z15.string().uuid().optional().describe("Filter by local entity ID"),
|
|
3768
|
+
limit: z15.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
|
|
3769
|
+
offset: z15.number().int().min(0).optional().describe("Number of items to skip (default 0)")
|
|
3488
3770
|
}
|
|
3489
3771
|
}, async ({
|
|
3490
3772
|
roadmapId,
|
|
@@ -3521,7 +3803,7 @@ function registerGetExport(server) {
|
|
|
3521
3803
|
server.registerTool("get_export", {
|
|
3522
3804
|
description: "Get full details of a single export record by ID.",
|
|
3523
3805
|
inputSchema: {
|
|
3524
|
-
id:
|
|
3806
|
+
id: z15.string().uuid().describe("The UUID of the export record")
|
|
3525
3807
|
}
|
|
3526
3808
|
}, async ({ id }) => {
|
|
3527
3809
|
const client2 = getApiClient();
|
|
@@ -3540,14 +3822,14 @@ function registerCreateExport(server) {
|
|
|
3540
3822
|
server.registerTool("create_export", {
|
|
3541
3823
|
description: "Record a new export (with upsert). If an export with the same roadmap, entity, and external system already exists, it will be updated.",
|
|
3542
3824
|
inputSchema: {
|
|
3543
|
-
roadmapId:
|
|
3544
|
-
localEntityType:
|
|
3545
|
-
localEntityId:
|
|
3546
|
-
externalSystem:
|
|
3547
|
-
externalObjectType:
|
|
3548
|
-
externalId:
|
|
3549
|
-
externalUrl:
|
|
3550
|
-
metadata:
|
|
3825
|
+
roadmapId: z15.string().uuid().describe("The UUID of the roadmap item"),
|
|
3826
|
+
localEntityType: z15.enum(["roadmap", "prd", "epic", "story", "design"]).describe("Type of local entity being exported"),
|
|
3827
|
+
localEntityId: z15.string().uuid().describe("The UUID of the local entity"),
|
|
3828
|
+
externalSystem: z15.enum(["linear", "notion", "jira", "github"]).describe("External system where the entity was exported"),
|
|
3829
|
+
externalObjectType: z15.string().min(1).describe('Type of object in the external system (e.g., "issue", "page", "project")'),
|
|
3830
|
+
externalId: z15.string().min(1).describe("ID of the object in the external system"),
|
|
3831
|
+
externalUrl: z15.string().url().optional().describe("URL to the object in the external system"),
|
|
3832
|
+
metadata: z15.record(z15.unknown()).optional().describe("Additional metadata about the export")
|
|
3551
3833
|
}
|
|
3552
3834
|
}, async ({
|
|
3553
3835
|
roadmapId,
|
|
@@ -3584,9 +3866,9 @@ function registerUpdateExport(server) {
|
|
|
3584
3866
|
server.registerTool("update_export", {
|
|
3585
3867
|
description: "Update an export record. Can update the external URL or metadata.",
|
|
3586
3868
|
inputSchema: {
|
|
3587
|
-
id:
|
|
3588
|
-
externalUrl:
|
|
3589
|
-
metadata:
|
|
3869
|
+
id: z15.string().uuid().describe("The UUID of the export record to update"),
|
|
3870
|
+
externalUrl: z15.string().url().nullable().optional().describe("New URL to the object in the external system"),
|
|
3871
|
+
metadata: z15.record(z15.unknown()).optional().describe("New metadata to replace existing metadata")
|
|
3590
3872
|
}
|
|
3591
3873
|
}, async ({
|
|
3592
3874
|
id,
|
|
@@ -3609,7 +3891,7 @@ function registerDeleteExport(server) {
|
|
|
3609
3891
|
server.registerTool("delete_export", {
|
|
3610
3892
|
description: "Delete an export record. This is a soft delete.",
|
|
3611
3893
|
inputSchema: {
|
|
3612
|
-
id:
|
|
3894
|
+
id: z15.string().uuid().describe("The UUID of the export record to delete")
|
|
3613
3895
|
}
|
|
3614
3896
|
}, async ({ id }) => {
|
|
3615
3897
|
const client2 = getApiClient();
|
|
@@ -3624,6 +3906,565 @@ function registerDeleteExport(server) {
|
|
|
3624
3906
|
};
|
|
3625
3907
|
});
|
|
3626
3908
|
}
|
|
3909
|
+
function registerListPresentations(server) {
|
|
3910
|
+
server.registerTool("list_presentations", {
|
|
3911
|
+
description: "List all presentations.",
|
|
3912
|
+
inputSchema: {}
|
|
3913
|
+
}, async () => {
|
|
3914
|
+
const client2 = getApiClient();
|
|
3915
|
+
const result = await client2.listPresentations();
|
|
3916
|
+
return {
|
|
3917
|
+
content: [
|
|
3918
|
+
{
|
|
3919
|
+
type: "text",
|
|
3920
|
+
text: JSON.stringify(result, null, 2)
|
|
3921
|
+
}
|
|
3922
|
+
]
|
|
3923
|
+
};
|
|
3924
|
+
});
|
|
3925
|
+
}
|
|
3926
|
+
function registerGetPresentation(server) {
|
|
3927
|
+
server.registerTool("get_presentation", {
|
|
3928
|
+
description: "Get presentation with variants and slides.",
|
|
3929
|
+
inputSchema: {
|
|
3930
|
+
id: z15.string().describe("The UUID of the presentation")
|
|
3931
|
+
}
|
|
3932
|
+
}, async ({ id }) => {
|
|
3933
|
+
const client2 = getApiClient();
|
|
3934
|
+
const presentation2 = await client2.getPresentation(id);
|
|
3935
|
+
const variantsResult = await client2.listVariants(id);
|
|
3936
|
+
const variantsWithSlides = await Promise.all(variantsResult.items.map(async (variant2) => {
|
|
3937
|
+
const slidesResult = await client2.listSlides(id, variant2.id);
|
|
3938
|
+
return {
|
|
3939
|
+
...variant2,
|
|
3940
|
+
slides: slidesResult.items
|
|
3941
|
+
};
|
|
3942
|
+
}));
|
|
3943
|
+
return {
|
|
3944
|
+
content: [
|
|
3945
|
+
{
|
|
3946
|
+
type: "text",
|
|
3947
|
+
text: JSON.stringify({
|
|
3948
|
+
...presentation2,
|
|
3949
|
+
variants: variantsWithSlides
|
|
3950
|
+
}, null, 2)
|
|
3951
|
+
}
|
|
3952
|
+
]
|
|
3953
|
+
};
|
|
3954
|
+
});
|
|
3955
|
+
}
|
|
3956
|
+
function registerCreatePresentation(server) {
|
|
3957
|
+
server.registerTool("create_presentation", {
|
|
3958
|
+
description: "Create a new presentation.",
|
|
3959
|
+
inputSchema: {
|
|
3960
|
+
title: z15.string().describe("Title of the presentation"),
|
|
3961
|
+
description: z15.string().nullable().optional().describe("Description of the presentation")
|
|
3962
|
+
}
|
|
3963
|
+
}, async ({ title, description }) => {
|
|
3964
|
+
const client2 = getApiClient();
|
|
3965
|
+
const presentation2 = await client2.createPresentation({
|
|
3966
|
+
title,
|
|
3967
|
+
description: description ?? null
|
|
3968
|
+
});
|
|
3969
|
+
return {
|
|
3970
|
+
content: [
|
|
3971
|
+
{
|
|
3972
|
+
type: "text",
|
|
3973
|
+
text: JSON.stringify(presentation2, null, 2)
|
|
3974
|
+
}
|
|
3975
|
+
]
|
|
3976
|
+
};
|
|
3977
|
+
});
|
|
3978
|
+
}
|
|
3979
|
+
function registerUpdatePresentation(server) {
|
|
3980
|
+
server.registerTool("update_presentation", {
|
|
3981
|
+
description: "Update an existing presentation.",
|
|
3982
|
+
inputSchema: {
|
|
3983
|
+
id: z15.string().describe("The UUID of the presentation to update"),
|
|
3984
|
+
title: z15.string().optional().describe("New title"),
|
|
3985
|
+
description: z15.string().nullable().optional().describe("New description")
|
|
3986
|
+
}
|
|
3987
|
+
}, async ({
|
|
3988
|
+
id,
|
|
3989
|
+
title,
|
|
3990
|
+
description
|
|
3991
|
+
}) => {
|
|
3992
|
+
const client2 = getApiClient();
|
|
3993
|
+
const data = {};
|
|
3994
|
+
if (title !== undefined)
|
|
3995
|
+
data.title = title;
|
|
3996
|
+
if (description !== undefined)
|
|
3997
|
+
data.description = description;
|
|
3998
|
+
const presentation2 = await client2.updatePresentation(id, data);
|
|
3999
|
+
return {
|
|
4000
|
+
content: [
|
|
4001
|
+
{
|
|
4002
|
+
type: "text",
|
|
4003
|
+
text: JSON.stringify(presentation2, null, 2)
|
|
4004
|
+
}
|
|
4005
|
+
]
|
|
4006
|
+
};
|
|
4007
|
+
});
|
|
4008
|
+
}
|
|
4009
|
+
function registerDeletePresentation(server) {
|
|
4010
|
+
server.registerTool("delete_presentation", {
|
|
4011
|
+
description: "Delete a presentation.",
|
|
4012
|
+
inputSchema: {
|
|
4013
|
+
id: z15.string().describe("The UUID of the presentation to delete")
|
|
4014
|
+
}
|
|
4015
|
+
}, async ({ id }) => {
|
|
4016
|
+
const client2 = getApiClient();
|
|
4017
|
+
await client2.deletePresentation(id);
|
|
4018
|
+
return {
|
|
4019
|
+
content: [
|
|
4020
|
+
{
|
|
4021
|
+
type: "text",
|
|
4022
|
+
text: JSON.stringify({ success: true, deleted: id }, null, 2)
|
|
4023
|
+
}
|
|
4024
|
+
]
|
|
4025
|
+
};
|
|
4026
|
+
});
|
|
4027
|
+
}
|
|
4028
|
+
function registerReorderPresentations(server) {
|
|
4029
|
+
server.registerTool("reorder_presentations", {
|
|
4030
|
+
description: "Reorder presentations by setting their order values. Lower order values appear first.",
|
|
4031
|
+
inputSchema: {
|
|
4032
|
+
items: z15.array(z15.object({
|
|
4033
|
+
id: z15.string().describe("The UUID of the presentation"),
|
|
4034
|
+
order: z15.number().int().min(0).describe("The new order value (0-based)")
|
|
4035
|
+
})).describe("Array of presentations with their new order values")
|
|
4036
|
+
}
|
|
4037
|
+
}, async ({ items }) => {
|
|
4038
|
+
const client2 = getApiClient();
|
|
4039
|
+
await client2.reorderPresentations(items);
|
|
4040
|
+
return {
|
|
4041
|
+
content: [
|
|
4042
|
+
{
|
|
4043
|
+
type: "text",
|
|
4044
|
+
text: JSON.stringify({ success: true, reordered: items.length }, null, 2)
|
|
4045
|
+
}
|
|
4046
|
+
]
|
|
4047
|
+
};
|
|
4048
|
+
});
|
|
4049
|
+
}
|
|
4050
|
+
function registerListVariants(server) {
|
|
4051
|
+
server.registerTool("list_variants", {
|
|
4052
|
+
description: "List all variants for a presentation.",
|
|
4053
|
+
inputSchema: {
|
|
4054
|
+
presentationId: z15.string().describe("The UUID of the presentation")
|
|
4055
|
+
}
|
|
4056
|
+
}, async ({ presentationId }) => {
|
|
4057
|
+
const client2 = getApiClient();
|
|
4058
|
+
const result = await client2.listVariants(presentationId);
|
|
4059
|
+
return {
|
|
4060
|
+
content: [
|
|
4061
|
+
{
|
|
4062
|
+
type: "text",
|
|
4063
|
+
text: JSON.stringify(result, null, 2)
|
|
4064
|
+
}
|
|
4065
|
+
]
|
|
4066
|
+
};
|
|
4067
|
+
});
|
|
4068
|
+
}
|
|
4069
|
+
function registerGetVariant(server) {
|
|
4070
|
+
server.registerTool("get_variant", {
|
|
4071
|
+
description: "Get variant with its slides.",
|
|
4072
|
+
inputSchema: {
|
|
4073
|
+
presentationId: z15.string().describe("The UUID of the presentation"),
|
|
4074
|
+
variantId: z15.string().describe("The UUID of the variant")
|
|
4075
|
+
}
|
|
4076
|
+
}, async ({ presentationId, variantId }) => {
|
|
4077
|
+
const client2 = getApiClient();
|
|
4078
|
+
const variant2 = await client2.getVariant(presentationId, variantId);
|
|
4079
|
+
const slidesResult = await client2.listSlides(presentationId, variantId);
|
|
4080
|
+
return {
|
|
4081
|
+
content: [
|
|
4082
|
+
{
|
|
4083
|
+
type: "text",
|
|
4084
|
+
text: JSON.stringify({
|
|
4085
|
+
...variant2,
|
|
4086
|
+
slides: slidesResult.items
|
|
4087
|
+
}, null, 2)
|
|
4088
|
+
}
|
|
4089
|
+
]
|
|
4090
|
+
};
|
|
4091
|
+
});
|
|
4092
|
+
}
|
|
4093
|
+
function registerCreateVariant(server) {
|
|
4094
|
+
server.registerTool("create_variant", {
|
|
4095
|
+
description: "Create a new variant for a presentation.",
|
|
4096
|
+
inputSchema: {
|
|
4097
|
+
presentationId: z15.string().describe("The UUID of the presentation"),
|
|
4098
|
+
name: z15.string().describe("Name of the variant"),
|
|
4099
|
+
audienceId: z15.string().nullable().optional().describe("The UUID of the target audience")
|
|
4100
|
+
}
|
|
4101
|
+
}, async ({
|
|
4102
|
+
presentationId,
|
|
4103
|
+
name,
|
|
4104
|
+
audienceId
|
|
4105
|
+
}) => {
|
|
4106
|
+
const client2 = getApiClient();
|
|
4107
|
+
const variant2 = await client2.createVariant(presentationId, {
|
|
4108
|
+
name,
|
|
4109
|
+
audienceId: audienceId ?? null
|
|
4110
|
+
});
|
|
4111
|
+
return {
|
|
4112
|
+
content: [
|
|
4113
|
+
{
|
|
4114
|
+
type: "text",
|
|
4115
|
+
text: JSON.stringify(variant2, null, 2)
|
|
4116
|
+
}
|
|
4117
|
+
]
|
|
4118
|
+
};
|
|
4119
|
+
});
|
|
4120
|
+
}
|
|
4121
|
+
function registerUpdateVariant(server) {
|
|
4122
|
+
server.registerTool("update_variant", {
|
|
4123
|
+
description: "Update an existing variant.",
|
|
4124
|
+
inputSchema: {
|
|
4125
|
+
presentationId: z15.string().describe("The UUID of the presentation"),
|
|
4126
|
+
variantId: z15.string().describe("The UUID of the variant to update"),
|
|
4127
|
+
name: z15.string().optional().describe("New name"),
|
|
4128
|
+
audienceId: z15.string().nullable().optional().describe("New target audience UUID")
|
|
4129
|
+
}
|
|
4130
|
+
}, async ({
|
|
4131
|
+
presentationId,
|
|
4132
|
+
variantId,
|
|
4133
|
+
name,
|
|
4134
|
+
audienceId
|
|
4135
|
+
}) => {
|
|
4136
|
+
const client2 = getApiClient();
|
|
4137
|
+
const data = {};
|
|
4138
|
+
if (name !== undefined)
|
|
4139
|
+
data.name = name;
|
|
4140
|
+
if (audienceId !== undefined)
|
|
4141
|
+
data.audienceId = audienceId;
|
|
4142
|
+
const variant2 = await client2.updateVariant(presentationId, variantId, data);
|
|
4143
|
+
return {
|
|
4144
|
+
content: [
|
|
4145
|
+
{
|
|
4146
|
+
type: "text",
|
|
4147
|
+
text: JSON.stringify(variant2, null, 2)
|
|
4148
|
+
}
|
|
4149
|
+
]
|
|
4150
|
+
};
|
|
4151
|
+
});
|
|
4152
|
+
}
|
|
4153
|
+
function registerDeleteVariant(server) {
|
|
4154
|
+
server.registerTool("delete_variant", {
|
|
4155
|
+
description: "Delete a variant.",
|
|
4156
|
+
inputSchema: {
|
|
4157
|
+
presentationId: z15.string().describe("The UUID of the presentation"),
|
|
4158
|
+
variantId: z15.string().describe("The UUID of the variant to delete")
|
|
4159
|
+
}
|
|
4160
|
+
}, async ({ presentationId, variantId }) => {
|
|
4161
|
+
const client2 = getApiClient();
|
|
4162
|
+
await client2.deleteVariant(presentationId, variantId);
|
|
4163
|
+
return {
|
|
4164
|
+
content: [
|
|
4165
|
+
{
|
|
4166
|
+
type: "text",
|
|
4167
|
+
text: JSON.stringify({ success: true, deleted: variantId }, null, 2)
|
|
4168
|
+
}
|
|
4169
|
+
]
|
|
4170
|
+
};
|
|
4171
|
+
});
|
|
4172
|
+
}
|
|
4173
|
+
function registerReorderVariants(server) {
|
|
4174
|
+
server.registerTool("reorder_variants", {
|
|
4175
|
+
description: "Reorder variants by setting their order values. Lower order values appear first.",
|
|
4176
|
+
inputSchema: {
|
|
4177
|
+
presentationId: z15.string().describe("The UUID of the presentation"),
|
|
4178
|
+
items: z15.array(z15.object({
|
|
4179
|
+
id: z15.string().describe("The UUID of the variant"),
|
|
4180
|
+
order: z15.number().int().min(0).describe("The new order value (0-based)")
|
|
4181
|
+
})).describe("Array of variants with their new order values")
|
|
4182
|
+
}
|
|
4183
|
+
}, async ({
|
|
4184
|
+
presentationId,
|
|
4185
|
+
items
|
|
4186
|
+
}) => {
|
|
4187
|
+
const client2 = getApiClient();
|
|
4188
|
+
await client2.reorderVariants(presentationId, items);
|
|
4189
|
+
return {
|
|
4190
|
+
content: [
|
|
4191
|
+
{
|
|
4192
|
+
type: "text",
|
|
4193
|
+
text: JSON.stringify({ success: true, reordered: items.length }, null, 2)
|
|
4194
|
+
}
|
|
4195
|
+
]
|
|
4196
|
+
};
|
|
4197
|
+
});
|
|
4198
|
+
}
|
|
4199
|
+
function registerCloneVariant(server) {
|
|
4200
|
+
server.registerTool("clone_variant", {
|
|
4201
|
+
description: "Clone a variant with all its slides.",
|
|
4202
|
+
inputSchema: {
|
|
4203
|
+
presentationId: z15.string().describe("The UUID of the presentation"),
|
|
4204
|
+
variantId: z15.string().describe("The UUID of the variant to clone")
|
|
4205
|
+
}
|
|
4206
|
+
}, async ({ presentationId, variantId }) => {
|
|
4207
|
+
const client2 = getApiClient();
|
|
4208
|
+
const clonedVariant = await client2.cloneVariant(presentationId, variantId);
|
|
4209
|
+
return {
|
|
4210
|
+
content: [
|
|
4211
|
+
{
|
|
4212
|
+
type: "text",
|
|
4213
|
+
text: JSON.stringify(clonedVariant, null, 2)
|
|
4214
|
+
}
|
|
4215
|
+
]
|
|
4216
|
+
};
|
|
4217
|
+
});
|
|
4218
|
+
}
|
|
4219
|
+
function registerSetDefaultVariant(server) {
|
|
4220
|
+
server.registerTool("set_default_variant", {
|
|
4221
|
+
description: "Set a variant as the default for the presentation.",
|
|
4222
|
+
inputSchema: {
|
|
4223
|
+
presentationId: z15.string().describe("The UUID of the presentation"),
|
|
4224
|
+
variantId: z15.string().describe("The UUID of the variant to set as default")
|
|
4225
|
+
}
|
|
4226
|
+
}, async ({ presentationId, variantId }) => {
|
|
4227
|
+
const client2 = getApiClient();
|
|
4228
|
+
await client2.setDefaultVariant(presentationId, variantId);
|
|
4229
|
+
return {
|
|
4230
|
+
content: [
|
|
4231
|
+
{
|
|
4232
|
+
type: "text",
|
|
4233
|
+
text: JSON.stringify({ success: true, variantId }, null, 2)
|
|
4234
|
+
}
|
|
4235
|
+
]
|
|
4236
|
+
};
|
|
4237
|
+
});
|
|
4238
|
+
}
|
|
4239
|
+
function registerListSlides(server) {
|
|
4240
|
+
server.registerTool("list_slides", {
|
|
4241
|
+
description: "List all slides in a variant.",
|
|
4242
|
+
inputSchema: {
|
|
4243
|
+
variantId: z15.string().describe("The UUID of the variant")
|
|
4244
|
+
}
|
|
4245
|
+
}, async ({ variantId }) => {
|
|
4246
|
+
const client2 = getApiClient();
|
|
4247
|
+
const presentationId = await client2.getVariantPresentationId(variantId);
|
|
4248
|
+
if (!presentationId) {
|
|
4249
|
+
return {
|
|
4250
|
+
content: [
|
|
4251
|
+
{
|
|
4252
|
+
type: "text",
|
|
4253
|
+
text: JSON.stringify({ error: "Variant not found" }, null, 2)
|
|
4254
|
+
}
|
|
4255
|
+
]
|
|
4256
|
+
};
|
|
4257
|
+
}
|
|
4258
|
+
const result = await client2.listSlides(presentationId, variantId);
|
|
4259
|
+
return {
|
|
4260
|
+
content: [
|
|
4261
|
+
{
|
|
4262
|
+
type: "text",
|
|
4263
|
+
text: JSON.stringify(result, null, 2)
|
|
4264
|
+
}
|
|
4265
|
+
]
|
|
4266
|
+
};
|
|
4267
|
+
});
|
|
4268
|
+
}
|
|
4269
|
+
function registerGetSlide(server) {
|
|
4270
|
+
server.registerTool("get_slide", {
|
|
4271
|
+
description: "Get a slide by ID.",
|
|
4272
|
+
inputSchema: {
|
|
4273
|
+
variantId: z15.string().describe("The UUID of the variant"),
|
|
4274
|
+
slideId: z15.string().describe("The UUID of the slide")
|
|
4275
|
+
}
|
|
4276
|
+
}, async ({ variantId, slideId }) => {
|
|
4277
|
+
const client2 = getApiClient();
|
|
4278
|
+
const presentationId = await client2.getVariantPresentationId(variantId);
|
|
4279
|
+
if (!presentationId) {
|
|
4280
|
+
return {
|
|
4281
|
+
content: [
|
|
4282
|
+
{
|
|
4283
|
+
type: "text",
|
|
4284
|
+
text: JSON.stringify({ error: "Variant not found" }, null, 2)
|
|
4285
|
+
}
|
|
4286
|
+
]
|
|
4287
|
+
};
|
|
4288
|
+
}
|
|
4289
|
+
const slide2 = await client2.getSlide(presentationId, variantId, slideId);
|
|
4290
|
+
return {
|
|
4291
|
+
content: [
|
|
4292
|
+
{
|
|
4293
|
+
type: "text",
|
|
4294
|
+
text: JSON.stringify(slide2, null, 2)
|
|
4295
|
+
}
|
|
4296
|
+
]
|
|
4297
|
+
};
|
|
4298
|
+
});
|
|
4299
|
+
}
|
|
4300
|
+
function registerCreateSlide(server) {
|
|
4301
|
+
server.registerTool("create_slide", {
|
|
4302
|
+
description: "Create a new slide in a variant. Slide types: title (title + subtitle), section_header (title + subtitle), bullets (title + items array), two_column (title + left/right text), comparison (leftLabel + leftContent + rightLabel + rightContent), timeline (title + steps array of {title, description}), image (title + imageUrl + caption), quote (quote + attribution), code (title + code + language), thank_you (title + subtitle).",
|
|
4303
|
+
inputSchema: {
|
|
4304
|
+
variantId: z15.string().describe("The UUID of the variant"),
|
|
4305
|
+
slideType: z15.enum([
|
|
4306
|
+
"title",
|
|
4307
|
+
"section_header",
|
|
4308
|
+
"bullets",
|
|
4309
|
+
"two_column",
|
|
4310
|
+
"comparison",
|
|
4311
|
+
"timeline",
|
|
4312
|
+
"image",
|
|
4313
|
+
"quote",
|
|
4314
|
+
"code",
|
|
4315
|
+
"thank_you"
|
|
4316
|
+
]).default("bullets").describe("The type of slide to create"),
|
|
4317
|
+
content: z15.record(z15.unknown()).optional().describe('Type-specific content object. For bullets: {title, items: ["..."]}. For title: {title, subtitle}. For two_column: {title, left, right}. For quote: {quote, attribution}. Etc.'),
|
|
4318
|
+
speakerNotes: z15.string().nullable().optional().describe("Speaker notes for the slide")
|
|
4319
|
+
}
|
|
4320
|
+
}, async ({
|
|
4321
|
+
variantId,
|
|
4322
|
+
slideType,
|
|
4323
|
+
content,
|
|
4324
|
+
speakerNotes
|
|
4325
|
+
}) => {
|
|
4326
|
+
const client2 = getApiClient();
|
|
4327
|
+
const presentationId = await client2.getVariantPresentationId(variantId);
|
|
4328
|
+
if (!presentationId) {
|
|
4329
|
+
return {
|
|
4330
|
+
content: [
|
|
4331
|
+
{
|
|
4332
|
+
type: "text",
|
|
4333
|
+
text: JSON.stringify({ error: "Variant not found" }, null, 2)
|
|
4334
|
+
}
|
|
4335
|
+
]
|
|
4336
|
+
};
|
|
4337
|
+
}
|
|
4338
|
+
const slide2 = await client2.createSlide(presentationId, variantId, {
|
|
4339
|
+
slideType: slideType || "bullets",
|
|
4340
|
+
content,
|
|
4341
|
+
speakerNotes
|
|
4342
|
+
});
|
|
4343
|
+
return {
|
|
4344
|
+
content: [
|
|
4345
|
+
{
|
|
4346
|
+
type: "text",
|
|
4347
|
+
text: JSON.stringify(slide2, null, 2)
|
|
4348
|
+
}
|
|
4349
|
+
]
|
|
4350
|
+
};
|
|
4351
|
+
});
|
|
4352
|
+
}
|
|
4353
|
+
function registerUpdateSlide(server) {
|
|
4354
|
+
server.registerTool("update_slide", {
|
|
4355
|
+
description: "Update an existing slide.",
|
|
4356
|
+
inputSchema: {
|
|
4357
|
+
variantId: z15.string().describe("The UUID of the variant"),
|
|
4358
|
+
slideId: z15.string().describe("The UUID of the slide to update"),
|
|
4359
|
+
title: z15.string().optional().describe("New title"),
|
|
4360
|
+
content: z15.object({ body: z15.string().optional() }).nullable().optional().describe("New slide content with markdown body"),
|
|
4361
|
+
speakerNotes: z15.string().nullable().optional().describe("New speaker notes")
|
|
4362
|
+
}
|
|
4363
|
+
}, async ({
|
|
4364
|
+
variantId,
|
|
4365
|
+
slideId,
|
|
4366
|
+
title,
|
|
4367
|
+
content,
|
|
4368
|
+
speakerNotes
|
|
4369
|
+
}) => {
|
|
4370
|
+
const client2 = getApiClient();
|
|
4371
|
+
const presentationId = await client2.getVariantPresentationId(variantId);
|
|
4372
|
+
if (!presentationId) {
|
|
4373
|
+
return {
|
|
4374
|
+
content: [
|
|
4375
|
+
{
|
|
4376
|
+
type: "text",
|
|
4377
|
+
text: JSON.stringify({ error: "Variant not found" }, null, 2)
|
|
4378
|
+
}
|
|
4379
|
+
]
|
|
4380
|
+
};
|
|
4381
|
+
}
|
|
4382
|
+
const data = {};
|
|
4383
|
+
if (title !== undefined)
|
|
4384
|
+
data.title = title;
|
|
4385
|
+
if (content !== undefined)
|
|
4386
|
+
data.content = content;
|
|
4387
|
+
if (speakerNotes !== undefined)
|
|
4388
|
+
data.speakerNotes = speakerNotes;
|
|
4389
|
+
const slide2 = await client2.updateSlide(presentationId, variantId, slideId, data);
|
|
4390
|
+
return {
|
|
4391
|
+
content: [
|
|
4392
|
+
{
|
|
4393
|
+
type: "text",
|
|
4394
|
+
text: JSON.stringify(slide2, null, 2)
|
|
4395
|
+
}
|
|
4396
|
+
]
|
|
4397
|
+
};
|
|
4398
|
+
});
|
|
4399
|
+
}
|
|
4400
|
+
function registerDeleteSlide(server) {
|
|
4401
|
+
server.registerTool("delete_slide", {
|
|
4402
|
+
description: "Delete a slide (soft delete).",
|
|
4403
|
+
inputSchema: {
|
|
4404
|
+
variantId: z15.string().describe("The UUID of the variant"),
|
|
4405
|
+
slideId: z15.string().describe("The UUID of the slide to delete")
|
|
4406
|
+
}
|
|
4407
|
+
}, async ({ variantId, slideId }) => {
|
|
4408
|
+
const client2 = getApiClient();
|
|
4409
|
+
const presentationId = await client2.getVariantPresentationId(variantId);
|
|
4410
|
+
if (!presentationId) {
|
|
4411
|
+
return {
|
|
4412
|
+
content: [
|
|
4413
|
+
{
|
|
4414
|
+
type: "text",
|
|
4415
|
+
text: JSON.stringify({ error: "Variant not found" }, null, 2)
|
|
4416
|
+
}
|
|
4417
|
+
]
|
|
4418
|
+
};
|
|
4419
|
+
}
|
|
4420
|
+
await client2.deleteSlide(presentationId, variantId, slideId);
|
|
4421
|
+
return {
|
|
4422
|
+
content: [
|
|
4423
|
+
{
|
|
4424
|
+
type: "text",
|
|
4425
|
+
text: JSON.stringify({ success: true, deleted: slideId }, null, 2)
|
|
4426
|
+
}
|
|
4427
|
+
]
|
|
4428
|
+
};
|
|
4429
|
+
});
|
|
4430
|
+
}
|
|
4431
|
+
function registerReorderSlides(server) {
|
|
4432
|
+
server.registerTool("reorder_slides", {
|
|
4433
|
+
description: "Reorder slides by setting their order values. Lower order values appear first.",
|
|
4434
|
+
inputSchema: {
|
|
4435
|
+
variantId: z15.string().describe("The UUID of the variant"),
|
|
4436
|
+
items: z15.array(z15.object({
|
|
4437
|
+
id: z15.string().describe("The UUID of the slide"),
|
|
4438
|
+
order: z15.number().int().min(0).describe("The new order value (0-based)")
|
|
4439
|
+
})).describe("Array of slides with their new order values")
|
|
4440
|
+
}
|
|
4441
|
+
}, async ({
|
|
4442
|
+
variantId,
|
|
4443
|
+
items
|
|
4444
|
+
}) => {
|
|
4445
|
+
const client2 = getApiClient();
|
|
4446
|
+
const presentationId = await client2.getVariantPresentationId(variantId);
|
|
4447
|
+
if (!presentationId) {
|
|
4448
|
+
return {
|
|
4449
|
+
content: [
|
|
4450
|
+
{
|
|
4451
|
+
type: "text",
|
|
4452
|
+
text: JSON.stringify({ error: "Variant not found" }, null, 2)
|
|
4453
|
+
}
|
|
4454
|
+
]
|
|
4455
|
+
};
|
|
4456
|
+
}
|
|
4457
|
+
await client2.reorderSlides(presentationId, variantId, items);
|
|
4458
|
+
return {
|
|
4459
|
+
content: [
|
|
4460
|
+
{
|
|
4461
|
+
type: "text",
|
|
4462
|
+
text: JSON.stringify({ success: true, reordered: items.length }, null, 2)
|
|
4463
|
+
}
|
|
4464
|
+
]
|
|
4465
|
+
};
|
|
4466
|
+
});
|
|
4467
|
+
}
|
|
3627
4468
|
|
|
3628
4469
|
// src/index.ts
|
|
3629
4470
|
async function main() {
|