@ourroadmaps/mcp 0.22.0 → 0.24.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 +709 -425
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -94,387 +94,427 @@ var domainContextSchema = z3.object({
|
|
|
94
94
|
definitions: z3.record(z3.string(), z3.string()),
|
|
95
95
|
schemas: z3.record(z3.string(), z3.array(z3.string()))
|
|
96
96
|
});
|
|
97
|
-
// ../../packages/shared/src/schemas/
|
|
97
|
+
// ../../packages/shared/src/schemas/export.ts
|
|
98
98
|
import { z as z4 } from "zod";
|
|
99
|
-
var
|
|
99
|
+
var localEntityTypeSchema = z4.enum(["roadmap", "prd", "epic", "story", "design"]);
|
|
100
|
+
var externalSystemSchema = z4.enum(["linear", "notion", "jira", "github"]);
|
|
101
|
+
var exportSchema = z4.object({
|
|
100
102
|
id: z4.string().uuid(),
|
|
101
|
-
|
|
102
|
-
|
|
103
|
+
roadmapItemId: z4.string().uuid(),
|
|
104
|
+
localEntityType: localEntityTypeSchema,
|
|
105
|
+
localEntityId: z4.string().uuid(),
|
|
106
|
+
externalSystem: externalSystemSchema,
|
|
107
|
+
externalObjectType: z4.string(),
|
|
108
|
+
externalId: z4.string(),
|
|
109
|
+
externalUrl: z4.string().nullable(),
|
|
110
|
+
metadata: z4.record(z4.unknown()).nullable(),
|
|
103
111
|
createdAt: z4.string(),
|
|
104
112
|
updatedAt: z4.string()
|
|
105
113
|
});
|
|
106
|
-
var
|
|
107
|
-
|
|
108
|
-
|
|
114
|
+
var createExportInputSchema = z4.object({
|
|
115
|
+
roadmapId: z4.string().uuid(),
|
|
116
|
+
localEntityType: localEntityTypeSchema,
|
|
117
|
+
localEntityId: z4.string().uuid(),
|
|
118
|
+
externalSystem: externalSystemSchema,
|
|
119
|
+
externalObjectType: z4.string().min(1),
|
|
120
|
+
externalId: z4.string().min(1),
|
|
121
|
+
externalUrl: z4.string().url().optional(),
|
|
122
|
+
metadata: z4.record(z4.unknown()).optional()
|
|
123
|
+
});
|
|
124
|
+
var updateExportInputSchema = z4.object({
|
|
125
|
+
externalUrl: z4.string().url().nullable().optional(),
|
|
126
|
+
metadata: z4.record(z4.unknown()).optional()
|
|
127
|
+
});
|
|
128
|
+
var searchExportsInputSchema = z4.object({
|
|
129
|
+
roadmapId: z4.string().uuid().optional(),
|
|
130
|
+
externalSystem: externalSystemSchema.optional(),
|
|
131
|
+
localEntityType: localEntityTypeSchema.optional(),
|
|
132
|
+
localEntityId: z4.string().uuid().optional(),
|
|
133
|
+
limit: z4.number().int().min(1).max(100).optional(),
|
|
134
|
+
offset: z4.number().int().min(0).optional()
|
|
135
|
+
});
|
|
136
|
+
// ../../packages/shared/src/schemas/feature.ts
|
|
137
|
+
import { z as z5 } from "zod";
|
|
138
|
+
var featureOutcomeSchema = z5.object({
|
|
139
|
+
id: z5.string().uuid(),
|
|
140
|
+
description: z5.string(),
|
|
141
|
+
order: z5.number().int(),
|
|
142
|
+
createdAt: z5.string(),
|
|
143
|
+
updatedAt: z5.string()
|
|
144
|
+
});
|
|
145
|
+
var featureSchema = z5.object({
|
|
146
|
+
id: z5.string().uuid(),
|
|
147
|
+
organizationId: z5.string(),
|
|
109
148
|
type: featureTypeSchema,
|
|
110
|
-
name:
|
|
111
|
-
description:
|
|
112
|
-
parentId:
|
|
113
|
-
order:
|
|
114
|
-
isExpanded:
|
|
115
|
-
deletedAt:
|
|
116
|
-
createdAt:
|
|
117
|
-
createdBy:
|
|
149
|
+
name: z5.string(),
|
|
150
|
+
description: z5.string().nullable(),
|
|
151
|
+
parentId: z5.string().uuid().nullable(),
|
|
152
|
+
order: z5.number().int(),
|
|
153
|
+
isExpanded: z5.boolean(),
|
|
154
|
+
deletedAt: z5.string().nullable(),
|
|
155
|
+
createdAt: z5.string(),
|
|
156
|
+
createdBy: z5.string()
|
|
118
157
|
});
|
|
119
|
-
var roadmapLinkSchema =
|
|
120
|
-
id:
|
|
121
|
-
roadmapId:
|
|
122
|
-
roadmap:
|
|
123
|
-
id:
|
|
124
|
-
title:
|
|
125
|
-
status:
|
|
126
|
-
horizon:
|
|
158
|
+
var roadmapLinkSchema = z5.object({
|
|
159
|
+
id: z5.string().uuid(),
|
|
160
|
+
roadmapId: z5.string().uuid(),
|
|
161
|
+
roadmap: z5.object({
|
|
162
|
+
id: z5.string().uuid(),
|
|
163
|
+
title: z5.string(),
|
|
164
|
+
status: z5.string(),
|
|
165
|
+
horizon: z5.string()
|
|
127
166
|
}),
|
|
128
|
-
createdAt:
|
|
167
|
+
createdAt: z5.string()
|
|
129
168
|
});
|
|
130
169
|
var featureWithRelationsSchema = featureSchema.extend({
|
|
131
|
-
outcomes:
|
|
132
|
-
roadmapLinks:
|
|
133
|
-
children:
|
|
170
|
+
outcomes: z5.array(featureOutcomeSchema),
|
|
171
|
+
roadmapLinks: z5.array(roadmapLinkSchema),
|
|
172
|
+
children: z5.array(featureSchema).optional()
|
|
134
173
|
});
|
|
135
|
-
var createFeatureSchema =
|
|
136
|
-
name:
|
|
137
|
-
description:
|
|
174
|
+
var createFeatureSchema = z5.object({
|
|
175
|
+
name: z5.string().min(1),
|
|
176
|
+
description: z5.string().nullable().optional(),
|
|
138
177
|
type: featureTypeSchema.optional(),
|
|
139
|
-
parentId:
|
|
178
|
+
parentId: z5.string().uuid().nullable().optional()
|
|
140
179
|
});
|
|
141
|
-
var updateFeatureSchema =
|
|
142
|
-
name:
|
|
143
|
-
description:
|
|
180
|
+
var updateFeatureSchema = z5.object({
|
|
181
|
+
name: z5.string().min(1).optional(),
|
|
182
|
+
description: z5.string().nullable().optional(),
|
|
144
183
|
type: featureTypeSchema.optional(),
|
|
145
|
-
parentId:
|
|
146
|
-
order:
|
|
184
|
+
parentId: z5.string().uuid().nullable().optional(),
|
|
185
|
+
order: z5.number().int().optional()
|
|
147
186
|
});
|
|
148
|
-
var saveFeatureOutcomesSchema =
|
|
149
|
-
outcomes:
|
|
150
|
-
id:
|
|
151
|
-
description:
|
|
187
|
+
var saveFeatureOutcomesSchema = z5.object({
|
|
188
|
+
outcomes: z5.array(z5.object({
|
|
189
|
+
id: z5.string().uuid().optional(),
|
|
190
|
+
description: z5.string()
|
|
152
191
|
}))
|
|
153
192
|
});
|
|
154
|
-
var featureListSchema =
|
|
193
|
+
var featureListSchema = z5.array(featureSchema);
|
|
155
194
|
// ../../packages/shared/src/schemas/idea.ts
|
|
156
|
-
import { z as
|
|
157
|
-
var ideaSchema =
|
|
158
|
-
id:
|
|
159
|
-
organizationId:
|
|
160
|
-
title:
|
|
161
|
-
description:
|
|
195
|
+
import { z as z6 } from "zod";
|
|
196
|
+
var ideaSchema = z6.object({
|
|
197
|
+
id: z6.string().uuid(),
|
|
198
|
+
organizationId: z6.string(),
|
|
199
|
+
title: z6.string(),
|
|
200
|
+
description: z6.string().nullable(),
|
|
162
201
|
status: ideaStatusSchema,
|
|
163
|
-
source:
|
|
164
|
-
submittedBy:
|
|
202
|
+
source: z6.string().nullable(),
|
|
203
|
+
submittedBy: z6.string().nullable(),
|
|
165
204
|
value: effortSchema.nullable(),
|
|
166
205
|
effort: effortSchema.nullable(),
|
|
167
|
-
order:
|
|
168
|
-
createdAt:
|
|
169
|
-
createdBy:
|
|
206
|
+
order: z6.number().int(),
|
|
207
|
+
createdAt: z6.string(),
|
|
208
|
+
createdBy: z6.string()
|
|
170
209
|
});
|
|
171
|
-
var createIdeaSchema =
|
|
172
|
-
title:
|
|
173
|
-
description:
|
|
210
|
+
var createIdeaSchema = z6.object({
|
|
211
|
+
title: z6.string().min(1),
|
|
212
|
+
description: z6.string().nullable().optional(),
|
|
174
213
|
status: ideaStatusSchema.optional(),
|
|
175
214
|
effort: effortSchema.nullable().optional(),
|
|
176
|
-
source:
|
|
215
|
+
source: z6.string().nullable().optional()
|
|
177
216
|
});
|
|
178
|
-
var updateIdeaSchema =
|
|
179
|
-
title:
|
|
180
|
-
description:
|
|
217
|
+
var updateIdeaSchema = z6.object({
|
|
218
|
+
title: z6.string().min(1).optional(),
|
|
219
|
+
description: z6.string().nullable().optional(),
|
|
181
220
|
status: ideaStatusSchema.optional(),
|
|
182
221
|
effort: effortSchema.nullable().optional(),
|
|
183
|
-
source:
|
|
184
|
-
order:
|
|
222
|
+
source: z6.string().nullable().optional(),
|
|
223
|
+
order: z6.number().int().optional()
|
|
185
224
|
});
|
|
186
|
-
var ideaListSchema =
|
|
225
|
+
var ideaListSchema = z6.array(ideaSchema);
|
|
187
226
|
// ../../packages/shared/src/schemas/product.ts
|
|
188
|
-
import { z as
|
|
189
|
-
var productSchema =
|
|
190
|
-
id:
|
|
191
|
-
organizationId:
|
|
192
|
-
parentId:
|
|
227
|
+
import { z as z7 } from "zod";
|
|
228
|
+
var productSchema = z7.object({
|
|
229
|
+
id: z7.string().uuid(),
|
|
230
|
+
organizationId: z7.string(),
|
|
231
|
+
parentId: z7.string().uuid().nullable(),
|
|
193
232
|
type: productTypeSchema,
|
|
194
|
-
name:
|
|
195
|
-
order:
|
|
196
|
-
isExpanded:
|
|
197
|
-
deletedAt:
|
|
198
|
-
createdAt:
|
|
233
|
+
name: z7.string(),
|
|
234
|
+
order: z7.number().int(),
|
|
235
|
+
isExpanded: z7.boolean(),
|
|
236
|
+
deletedAt: z7.string().nullable(),
|
|
237
|
+
createdAt: z7.string()
|
|
199
238
|
});
|
|
200
|
-
var createProductSchema =
|
|
201
|
-
name:
|
|
202
|
-
description:
|
|
239
|
+
var createProductSchema = z7.object({
|
|
240
|
+
name: z7.string().min(1),
|
|
241
|
+
description: z7.string().nullable().optional(),
|
|
203
242
|
type: productTypeSchema,
|
|
204
|
-
parentId:
|
|
243
|
+
parentId: z7.string().uuid().nullable().optional()
|
|
205
244
|
});
|
|
206
|
-
var updateProductSchema =
|
|
207
|
-
name:
|
|
208
|
-
description:
|
|
245
|
+
var updateProductSchema = z7.object({
|
|
246
|
+
name: z7.string().min(1).optional(),
|
|
247
|
+
description: z7.string().nullable().optional(),
|
|
209
248
|
type: productTypeSchema.optional(),
|
|
210
|
-
parentId:
|
|
211
|
-
order:
|
|
249
|
+
parentId: z7.string().uuid().nullable().optional(),
|
|
250
|
+
order: z7.number().int().optional()
|
|
212
251
|
});
|
|
213
|
-
var productListSchema =
|
|
252
|
+
var productListSchema = z7.array(productSchema);
|
|
214
253
|
// ../../packages/shared/src/schemas/roadmap.ts
|
|
215
|
-
import { z as
|
|
254
|
+
import { z as z9 } from "zod";
|
|
216
255
|
|
|
217
256
|
// ../../packages/shared/src/schemas/story.ts
|
|
218
|
-
import { z as
|
|
219
|
-
var epicSchema =
|
|
220
|
-
id:
|
|
221
|
-
roadmapItemId:
|
|
222
|
-
organizationId:
|
|
223
|
-
title:
|
|
224
|
-
description:
|
|
225
|
-
order:
|
|
226
|
-
createdAt:
|
|
227
|
-
updatedAt:
|
|
228
|
-
deletedAt:
|
|
257
|
+
import { z as z8 } from "zod";
|
|
258
|
+
var epicSchema = z8.object({
|
|
259
|
+
id: z8.string().uuid(),
|
|
260
|
+
roadmapItemId: z8.string().uuid(),
|
|
261
|
+
organizationId: z8.string(),
|
|
262
|
+
title: z8.string(),
|
|
263
|
+
description: z8.string().nullable(),
|
|
264
|
+
order: z8.number().int(),
|
|
265
|
+
createdAt: z8.string(),
|
|
266
|
+
updatedAt: z8.string(),
|
|
267
|
+
deletedAt: z8.string().nullable()
|
|
229
268
|
});
|
|
230
|
-
var storySchema =
|
|
231
|
-
id:
|
|
232
|
-
roadmapItemId:
|
|
233
|
-
epicId:
|
|
234
|
-
organizationId:
|
|
235
|
-
title:
|
|
236
|
-
description:
|
|
237
|
-
order:
|
|
238
|
-
createdAt:
|
|
239
|
-
updatedAt:
|
|
240
|
-
deletedAt:
|
|
269
|
+
var storySchema = z8.object({
|
|
270
|
+
id: z8.string().uuid(),
|
|
271
|
+
roadmapItemId: z8.string().uuid(),
|
|
272
|
+
epicId: z8.string().uuid().nullable(),
|
|
273
|
+
organizationId: z8.string(),
|
|
274
|
+
title: z8.string(),
|
|
275
|
+
description: z8.string().nullable(),
|
|
276
|
+
order: z8.number().int(),
|
|
277
|
+
createdAt: z8.string(),
|
|
278
|
+
updatedAt: z8.string(),
|
|
279
|
+
deletedAt: z8.string().nullable()
|
|
241
280
|
});
|
|
242
281
|
var epicWithStoriesSchema = epicSchema.extend({
|
|
243
|
-
stories:
|
|
282
|
+
stories: z8.array(storySchema)
|
|
244
283
|
});
|
|
245
|
-
var createEpicSchema =
|
|
246
|
-
title:
|
|
247
|
-
description:
|
|
284
|
+
var createEpicSchema = z8.object({
|
|
285
|
+
title: z8.string().min(1),
|
|
286
|
+
description: z8.string().nullable().optional()
|
|
248
287
|
});
|
|
249
|
-
var createStorySchema =
|
|
250
|
-
title:
|
|
251
|
-
description:
|
|
288
|
+
var createStorySchema = z8.object({
|
|
289
|
+
title: z8.string().min(1),
|
|
290
|
+
description: z8.string().nullable().optional()
|
|
252
291
|
});
|
|
253
|
-
var saveStoriesInputSchema =
|
|
254
|
-
epics:
|
|
255
|
-
title:
|
|
256
|
-
description:
|
|
257
|
-
stories:
|
|
258
|
-
title:
|
|
259
|
-
description:
|
|
292
|
+
var saveStoriesInputSchema = z8.object({
|
|
293
|
+
epics: z8.array(z8.object({
|
|
294
|
+
title: z8.string().min(1),
|
|
295
|
+
description: z8.string().nullable().optional(),
|
|
296
|
+
stories: z8.array(z8.object({
|
|
297
|
+
title: z8.string().min(1),
|
|
298
|
+
description: z8.string().nullable().optional()
|
|
260
299
|
})).optional().default([])
|
|
261
300
|
})).optional().default([]),
|
|
262
|
-
stories:
|
|
263
|
-
title:
|
|
264
|
-
description:
|
|
301
|
+
stories: z8.array(z8.object({
|
|
302
|
+
title: z8.string().min(1),
|
|
303
|
+
description: z8.string().nullable().optional()
|
|
265
304
|
})).optional().default([])
|
|
266
305
|
});
|
|
267
|
-
var updateEpicSchema =
|
|
268
|
-
title:
|
|
269
|
-
description:
|
|
306
|
+
var updateEpicSchema = z8.object({
|
|
307
|
+
title: z8.string().min(1).optional(),
|
|
308
|
+
description: z8.string().nullable().optional()
|
|
270
309
|
});
|
|
271
|
-
var updateStorySchema =
|
|
272
|
-
title:
|
|
273
|
-
description:
|
|
274
|
-
epicId:
|
|
310
|
+
var updateStorySchema = z8.object({
|
|
311
|
+
title: z8.string().min(1).optional(),
|
|
312
|
+
description: z8.string().nullable().optional(),
|
|
313
|
+
epicId: z8.string().uuid().nullable().optional()
|
|
275
314
|
});
|
|
276
|
-
var reorderStoriesSchema =
|
|
277
|
-
epicOrder:
|
|
278
|
-
storyOrder:
|
|
279
|
-
standaloneOrder:
|
|
315
|
+
var reorderStoriesSchema = z8.object({
|
|
316
|
+
epicOrder: z8.array(z8.string().uuid()).optional(),
|
|
317
|
+
storyOrder: z8.record(z8.string(), z8.array(z8.string().uuid())).optional(),
|
|
318
|
+
standaloneOrder: z8.array(z8.string().uuid()).optional()
|
|
280
319
|
});
|
|
281
320
|
|
|
282
321
|
// ../../packages/shared/src/schemas/roadmap.ts
|
|
283
|
-
var flexibleDateSchema =
|
|
284
|
-
value:
|
|
322
|
+
var flexibleDateSchema = z9.object({
|
|
323
|
+
value: z9.string(),
|
|
285
324
|
granularity: dateGranularitySchema
|
|
286
325
|
});
|
|
287
|
-
var labelSchema =
|
|
288
|
-
id:
|
|
289
|
-
type:
|
|
290
|
-
name:
|
|
291
|
-
color:
|
|
292
|
-
address:
|
|
326
|
+
var labelSchema = z9.object({
|
|
327
|
+
id: z9.string().uuid(),
|
|
328
|
+
type: z9.enum(["category", "location", "label"]),
|
|
329
|
+
name: z9.string(),
|
|
330
|
+
color: z9.string().nullable(),
|
|
331
|
+
address: z9.string().nullable()
|
|
293
332
|
});
|
|
294
|
-
var appSchema =
|
|
295
|
-
id:
|
|
296
|
-
name:
|
|
333
|
+
var appSchema = z9.object({
|
|
334
|
+
id: z9.string().uuid(),
|
|
335
|
+
name: z9.string()
|
|
297
336
|
});
|
|
298
|
-
var roadmapSchema =
|
|
299
|
-
id:
|
|
300
|
-
organizationId:
|
|
301
|
-
title:
|
|
337
|
+
var roadmapSchema = z9.object({
|
|
338
|
+
id: z9.string().uuid(),
|
|
339
|
+
organizationId: z9.string(),
|
|
340
|
+
title: z9.string(),
|
|
302
341
|
horizon: horizonSchema.nullable(),
|
|
303
342
|
status: roadmapStatusSchema.nullable(),
|
|
304
343
|
value: effortSchema.nullable(),
|
|
305
344
|
effort: effortSchema.nullable(),
|
|
306
|
-
order:
|
|
307
|
-
estimatedSeconds:
|
|
345
|
+
order: z9.number().int(),
|
|
346
|
+
estimatedSeconds: z9.number().int().nullable(),
|
|
308
347
|
date: flexibleDateSchema.nullable(),
|
|
309
348
|
target: flexibleDateSchema.nullable(),
|
|
310
|
-
completedAt:
|
|
311
|
-
createdAt:
|
|
312
|
-
createdBy:
|
|
313
|
-
prompt:
|
|
314
|
-
labels:
|
|
315
|
-
apps:
|
|
349
|
+
completedAt: z9.string().nullable(),
|
|
350
|
+
createdAt: z9.string(),
|
|
351
|
+
createdBy: z9.string(),
|
|
352
|
+
prompt: z9.string().nullable(),
|
|
353
|
+
labels: z9.array(labelSchema),
|
|
354
|
+
apps: z9.array(appSchema)
|
|
316
355
|
});
|
|
317
|
-
var createRoadmapSchema =
|
|
318
|
-
title:
|
|
356
|
+
var createRoadmapSchema = z9.object({
|
|
357
|
+
title: z9.string().min(1),
|
|
319
358
|
status: roadmapStatusSchema.optional(),
|
|
320
359
|
horizon: horizonSchema.optional(),
|
|
321
360
|
value: effortSchema.nullable().optional(),
|
|
322
361
|
effort: effortSchema.nullable().optional(),
|
|
323
|
-
estimatedSeconds:
|
|
362
|
+
estimatedSeconds: z9.number().int().nullable().optional(),
|
|
324
363
|
date: flexibleDateSchema.nullable().optional(),
|
|
325
364
|
target: flexibleDateSchema.nullable().optional(),
|
|
326
|
-
prompt:
|
|
327
|
-
brainstormNotes:
|
|
365
|
+
prompt: z9.string().nullable().optional(),
|
|
366
|
+
brainstormNotes: z9.string().nullable().optional()
|
|
328
367
|
});
|
|
329
|
-
var updateRoadmapSchema =
|
|
330
|
-
title:
|
|
368
|
+
var updateRoadmapSchema = z9.object({
|
|
369
|
+
title: z9.string().min(1).optional(),
|
|
331
370
|
status: roadmapStatusSchema.optional(),
|
|
332
371
|
horizon: horizonSchema.optional(),
|
|
333
372
|
value: effortSchema.nullable().optional(),
|
|
334
373
|
effort: effortSchema.nullable().optional(),
|
|
335
|
-
order:
|
|
336
|
-
estimatedSeconds:
|
|
374
|
+
order: z9.number().int().optional(),
|
|
375
|
+
estimatedSeconds: z9.number().int().nullable().optional(),
|
|
337
376
|
date: flexibleDateSchema.nullable().optional(),
|
|
338
377
|
target: flexibleDateSchema.nullable().optional(),
|
|
339
|
-
prompt:
|
|
340
|
-
brainstormNotes:
|
|
378
|
+
prompt: z9.string().nullable().optional(),
|
|
379
|
+
brainstormNotes: z9.string().nullable().optional()
|
|
341
380
|
});
|
|
342
|
-
var prdOutcomeSchema =
|
|
343
|
-
id:
|
|
344
|
-
description:
|
|
381
|
+
var prdOutcomeSchema = z9.object({
|
|
382
|
+
id: z9.string().uuid(),
|
|
383
|
+
description: z9.string(),
|
|
345
384
|
status: prdStatusSchema,
|
|
346
|
-
order:
|
|
347
|
-
completedAt:
|
|
385
|
+
order: z9.number().int(),
|
|
386
|
+
completedAt: z9.string().nullable()
|
|
348
387
|
});
|
|
349
|
-
var prdSchema =
|
|
350
|
-
id:
|
|
351
|
-
what:
|
|
352
|
-
why:
|
|
353
|
-
outcomes:
|
|
388
|
+
var prdSchema = z9.object({
|
|
389
|
+
id: z9.string().uuid(),
|
|
390
|
+
what: z9.string().nullable(),
|
|
391
|
+
why: z9.string().nullable(),
|
|
392
|
+
outcomes: z9.array(prdOutcomeSchema)
|
|
354
393
|
});
|
|
355
|
-
var savePrdInputSchema =
|
|
356
|
-
what:
|
|
357
|
-
why:
|
|
394
|
+
var savePrdInputSchema = z9.object({
|
|
395
|
+
what: z9.string().nullable(),
|
|
396
|
+
why: z9.string().nullable(),
|
|
358
397
|
status: prdStatusSchema,
|
|
359
|
-
outcomes:
|
|
360
|
-
id:
|
|
361
|
-
description:
|
|
362
|
-
order:
|
|
398
|
+
outcomes: z9.array(z9.object({
|
|
399
|
+
id: z9.string().uuid().optional(),
|
|
400
|
+
description: z9.string(),
|
|
401
|
+
order: z9.number().int().min(0)
|
|
363
402
|
}))
|
|
364
403
|
});
|
|
365
|
-
var brainstormMediaSchema =
|
|
366
|
-
id:
|
|
367
|
-
mediaUrl:
|
|
404
|
+
var brainstormMediaSchema = z9.object({
|
|
405
|
+
id: z9.string().uuid(),
|
|
406
|
+
mediaUrl: z9.string(),
|
|
368
407
|
mediaType: brainstormMediaTypeSchema,
|
|
369
|
-
description:
|
|
370
|
-
order:
|
|
371
|
-
createdAt:
|
|
408
|
+
description: z9.string().nullable(),
|
|
409
|
+
order: z9.number().int(),
|
|
410
|
+
createdAt: z9.string()
|
|
372
411
|
});
|
|
373
|
-
var wireframeSchema =
|
|
374
|
-
id:
|
|
375
|
-
description:
|
|
376
|
-
imageUrl:
|
|
377
|
-
order:
|
|
412
|
+
var wireframeSchema = z9.object({
|
|
413
|
+
id: z9.string().uuid(),
|
|
414
|
+
description: z9.string().nullable(),
|
|
415
|
+
imageUrl: z9.string().nullable(),
|
|
416
|
+
order: z9.number().int()
|
|
378
417
|
});
|
|
379
|
-
var prototypeSchema =
|
|
380
|
-
id:
|
|
381
|
-
publicUrl:
|
|
382
|
-
expiresAt:
|
|
383
|
-
fileCount:
|
|
384
|
-
entryPoint:
|
|
385
|
-
createdAt:
|
|
418
|
+
var prototypeSchema = z9.object({
|
|
419
|
+
id: z9.string().uuid(),
|
|
420
|
+
publicUrl: z9.string().url(),
|
|
421
|
+
expiresAt: z9.string().datetime(),
|
|
422
|
+
fileCount: z9.number().int().positive(),
|
|
423
|
+
entryPoint: z9.string(),
|
|
424
|
+
createdAt: z9.string().datetime()
|
|
386
425
|
});
|
|
387
|
-
var featureLinkSchema =
|
|
388
|
-
id:
|
|
389
|
-
featureId:
|
|
390
|
-
feature:
|
|
391
|
-
id:
|
|
392
|
-
name:
|
|
393
|
-
type:
|
|
426
|
+
var featureLinkSchema = z9.object({
|
|
427
|
+
id: z9.string().uuid(),
|
|
428
|
+
featureId: z9.string().uuid(),
|
|
429
|
+
feature: z9.object({
|
|
430
|
+
id: z9.string().uuid(),
|
|
431
|
+
name: z9.string(),
|
|
432
|
+
type: z9.enum(["area", "feature"])
|
|
394
433
|
}),
|
|
395
|
-
createdAt:
|
|
434
|
+
createdAt: z9.string()
|
|
396
435
|
});
|
|
397
|
-
var phaseDesignSchema =
|
|
398
|
-
id:
|
|
399
|
-
description:
|
|
436
|
+
var phaseDesignSchema = z9.object({
|
|
437
|
+
id: z9.string().uuid(),
|
|
438
|
+
description: z9.string().nullable()
|
|
400
439
|
});
|
|
401
|
-
var phasePlanSchema =
|
|
402
|
-
id:
|
|
403
|
-
description:
|
|
440
|
+
var phasePlanSchema = z9.object({
|
|
441
|
+
id: z9.string().uuid(),
|
|
442
|
+
description: z9.string().nullable()
|
|
404
443
|
});
|
|
405
|
-
var phaseBuildSchema =
|
|
406
|
-
id:
|
|
407
|
-
description:
|
|
408
|
-
prompt:
|
|
444
|
+
var phaseBuildSchema = z9.object({
|
|
445
|
+
id: z9.string().uuid(),
|
|
446
|
+
description: z9.string().nullable(),
|
|
447
|
+
prompt: z9.string().nullable()
|
|
409
448
|
});
|
|
410
|
-
var phaseReleaseSchema =
|
|
411
|
-
id:
|
|
412
|
-
description:
|
|
449
|
+
var phaseReleaseSchema = z9.object({
|
|
450
|
+
id: z9.string().uuid(),
|
|
451
|
+
description: z9.string().nullable()
|
|
413
452
|
});
|
|
414
453
|
var roadmapDetailSchema = roadmapSchema.extend({
|
|
415
454
|
prd: prdSchema.nullable(),
|
|
416
|
-
wireframes:
|
|
417
|
-
prototypes:
|
|
418
|
-
brainstormMedia:
|
|
419
|
-
brainstormNotes:
|
|
420
|
-
featureLinks:
|
|
421
|
-
epics:
|
|
422
|
-
stories:
|
|
455
|
+
wireframes: z9.array(wireframeSchema),
|
|
456
|
+
prototypes: z9.array(prototypeSchema),
|
|
457
|
+
brainstormMedia: z9.array(brainstormMediaSchema),
|
|
458
|
+
brainstormNotes: z9.string().nullable(),
|
|
459
|
+
featureLinks: z9.array(featureLinkSchema),
|
|
460
|
+
epics: z9.array(epicWithStoriesSchema),
|
|
461
|
+
stories: z9.array(storySchema),
|
|
423
462
|
design: phaseDesignSchema.nullable(),
|
|
424
463
|
plan: phasePlanSchema.nullable(),
|
|
425
464
|
build: phaseBuildSchema.nullable(),
|
|
426
|
-
release: phaseReleaseSchema.nullable()
|
|
465
|
+
release: phaseReleaseSchema.nullable(),
|
|
466
|
+
exports: z9.array(exportSchema)
|
|
427
467
|
});
|
|
428
|
-
var roadmapListSchema =
|
|
468
|
+
var roadmapListSchema = z9.array(roadmapSchema);
|
|
429
469
|
// ../../packages/shared/src/schemas/scenario.ts
|
|
430
|
-
import { z as
|
|
431
|
-
var scenarioSchema =
|
|
432
|
-
id:
|
|
433
|
-
title:
|
|
434
|
-
given:
|
|
435
|
-
when:
|
|
436
|
-
then:
|
|
437
|
-
order:
|
|
438
|
-
createdAt:
|
|
439
|
-
updatedAt:
|
|
470
|
+
import { z as z10 } from "zod";
|
|
471
|
+
var scenarioSchema = z10.object({
|
|
472
|
+
id: z10.string().uuid(),
|
|
473
|
+
title: z10.string().min(1),
|
|
474
|
+
given: z10.string().nullable(),
|
|
475
|
+
when: z10.string().nullable(),
|
|
476
|
+
then: z10.string().nullable(),
|
|
477
|
+
order: z10.number().int(),
|
|
478
|
+
createdAt: z10.string().datetime(),
|
|
479
|
+
updatedAt: z10.string().datetime()
|
|
440
480
|
});
|
|
441
|
-
var createScenarioSchema =
|
|
442
|
-
title:
|
|
443
|
-
given:
|
|
444
|
-
when:
|
|
445
|
-
then:
|
|
446
|
-
roadmapId:
|
|
481
|
+
var createScenarioSchema = z10.object({
|
|
482
|
+
title: z10.string().min(1),
|
|
483
|
+
given: z10.string().nullable().optional(),
|
|
484
|
+
when: z10.string().nullable().optional(),
|
|
485
|
+
then: z10.string().nullable().optional(),
|
|
486
|
+
roadmapId: z10.string().uuid()
|
|
447
487
|
});
|
|
448
|
-
var updateScenarioSchema =
|
|
449
|
-
title:
|
|
450
|
-
given:
|
|
451
|
-
when:
|
|
452
|
-
then:
|
|
453
|
-
order:
|
|
488
|
+
var updateScenarioSchema = z10.object({
|
|
489
|
+
title: z10.string().min(1).optional(),
|
|
490
|
+
given: z10.string().nullable().optional(),
|
|
491
|
+
when: z10.string().nullable().optional(),
|
|
492
|
+
then: z10.string().nullable().optional(),
|
|
493
|
+
order: z10.number().int().optional()
|
|
454
494
|
});
|
|
455
|
-
var scenarioListSchema =
|
|
495
|
+
var scenarioListSchema = z10.array(scenarioSchema);
|
|
456
496
|
// ../../packages/shared/src/schemas/status-update.ts
|
|
457
|
-
import { z as
|
|
458
|
-
var statusUpdateItemSchema =
|
|
459
|
-
id:
|
|
460
|
-
roadmapItemId:
|
|
461
|
-
titleAtSnapshot:
|
|
462
|
-
statusAtSnapshot:
|
|
463
|
-
designWalkthroughUrl:
|
|
464
|
-
releaseWalkthroughUrl:
|
|
497
|
+
import { z as z11 } from "zod";
|
|
498
|
+
var statusUpdateItemSchema = z11.object({
|
|
499
|
+
id: z11.string().uuid(),
|
|
500
|
+
roadmapItemId: z11.string().uuid(),
|
|
501
|
+
titleAtSnapshot: z11.string(),
|
|
502
|
+
statusAtSnapshot: z11.string(),
|
|
503
|
+
designWalkthroughUrl: z11.string().nullable(),
|
|
504
|
+
releaseWalkthroughUrl: z11.string().nullable()
|
|
465
505
|
});
|
|
466
|
-
var statusUpdateSchema =
|
|
467
|
-
id:
|
|
468
|
-
title:
|
|
469
|
-
startDate:
|
|
470
|
-
endDate:
|
|
471
|
-
content:
|
|
472
|
-
createdAt:
|
|
473
|
-
items:
|
|
506
|
+
var statusUpdateSchema = z11.object({
|
|
507
|
+
id: z11.string().uuid(),
|
|
508
|
+
title: z11.string().nullable(),
|
|
509
|
+
startDate: z11.string(),
|
|
510
|
+
endDate: z11.string(),
|
|
511
|
+
content: z11.string(),
|
|
512
|
+
createdAt: z11.string(),
|
|
513
|
+
items: z11.array(statusUpdateItemSchema).optional()
|
|
474
514
|
});
|
|
475
|
-
var statusUpdateListSchema =
|
|
515
|
+
var statusUpdateListSchema = z11.array(statusUpdateSchema);
|
|
476
516
|
// src/tools/index.ts
|
|
477
|
-
import { z as
|
|
517
|
+
import { z as z12 } from "zod";
|
|
478
518
|
|
|
479
519
|
// src/auth.ts
|
|
480
520
|
function getCredentials() {
|
|
@@ -971,6 +1011,45 @@ class ApiClient {
|
|
|
971
1011
|
throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
|
|
972
1012
|
}
|
|
973
1013
|
}
|
|
1014
|
+
async searchExports(params) {
|
|
1015
|
+
const searchParams = new URLSearchParams;
|
|
1016
|
+
if (params?.roadmapId)
|
|
1017
|
+
searchParams.set("roadmapId", params.roadmapId);
|
|
1018
|
+
if (params?.externalSystem)
|
|
1019
|
+
searchParams.set("externalSystem", params.externalSystem);
|
|
1020
|
+
if (params?.localEntityType)
|
|
1021
|
+
searchParams.set("localEntityType", params.localEntityType);
|
|
1022
|
+
if (params?.localEntityId)
|
|
1023
|
+
searchParams.set("localEntityId", params.localEntityId);
|
|
1024
|
+
if (params?.limit)
|
|
1025
|
+
searchParams.set("limit", String(params.limit));
|
|
1026
|
+
if (params?.offset)
|
|
1027
|
+
searchParams.set("offset", String(params.offset));
|
|
1028
|
+
const queryString = searchParams.toString();
|
|
1029
|
+
const path = queryString ? `/v1/exports?${queryString}` : "/v1/exports";
|
|
1030
|
+
return await this.request(path);
|
|
1031
|
+
}
|
|
1032
|
+
async getExport(id) {
|
|
1033
|
+
const response = await this.request(`/v1/exports/${id}`);
|
|
1034
|
+
return response.data;
|
|
1035
|
+
}
|
|
1036
|
+
async createExport(data) {
|
|
1037
|
+
const response = await this.request("/v1/exports", {
|
|
1038
|
+
method: "POST",
|
|
1039
|
+
body: JSON.stringify(data)
|
|
1040
|
+
});
|
|
1041
|
+
return response.data;
|
|
1042
|
+
}
|
|
1043
|
+
async updateExport(id, data) {
|
|
1044
|
+
const response = await this.request(`/v1/exports/${id}`, {
|
|
1045
|
+
method: "PATCH",
|
|
1046
|
+
body: JSON.stringify(data)
|
|
1047
|
+
});
|
|
1048
|
+
return response.data;
|
|
1049
|
+
}
|
|
1050
|
+
async deleteExport(id) {
|
|
1051
|
+
await this.request(`/v1/exports/${id}`, { method: "DELETE" });
|
|
1052
|
+
}
|
|
974
1053
|
}
|
|
975
1054
|
var client = null;
|
|
976
1055
|
function getApiClient() {
|
|
@@ -996,6 +1075,7 @@ function inferContentType(filename) {
|
|
|
996
1075
|
return ext ? mapping[ext] ?? null : null;
|
|
997
1076
|
}
|
|
998
1077
|
function registerAllTools(server) {
|
|
1078
|
+
registerGetWorkflows(server);
|
|
999
1079
|
registerSearchRoadmaps(server);
|
|
1000
1080
|
registerGetRoadmap(server);
|
|
1001
1081
|
registerSearchFeatures(server);
|
|
@@ -1054,26 +1134,59 @@ function registerAllTools(server) {
|
|
|
1054
1134
|
registerUploadDesignWalkthrough(server);
|
|
1055
1135
|
registerUploadReleaseWalkthrough(server);
|
|
1056
1136
|
registerPublishPrototype(server);
|
|
1137
|
+
registerSearchExports(server);
|
|
1138
|
+
registerGetExport(server);
|
|
1139
|
+
registerCreateExport(server);
|
|
1140
|
+
registerUpdateExport(server);
|
|
1141
|
+
registerDeleteExport(server);
|
|
1142
|
+
}
|
|
1143
|
+
function registerGetWorkflows(server) {
|
|
1144
|
+
server.registerTool("get_workflows", {
|
|
1145
|
+
description: "Get all workflow definitions with phases and steps. Use this to know valid phases/steps when updating roadmap items.",
|
|
1146
|
+
inputSchema: {}
|
|
1147
|
+
}, async () => {
|
|
1148
|
+
const client2 = getApiClient();
|
|
1149
|
+
const response = await client2.get("/v1/workflows");
|
|
1150
|
+
return {
|
|
1151
|
+
content: [
|
|
1152
|
+
{
|
|
1153
|
+
type: "text",
|
|
1154
|
+
text: JSON.stringify(response, null, 2)
|
|
1155
|
+
}
|
|
1156
|
+
]
|
|
1157
|
+
};
|
|
1158
|
+
});
|
|
1057
1159
|
}
|
|
1058
1160
|
function registerSearchRoadmaps(server) {
|
|
1059
1161
|
server.registerTool("search_roadmaps", {
|
|
1060
1162
|
description: "Search for roadmap items by title, status, or horizon. Returns a list of matching roadmap items with basic info.",
|
|
1061
1163
|
inputSchema: {
|
|
1062
|
-
query:
|
|
1164
|
+
query: z12.string().optional().describe("Search query to match against title or description"),
|
|
1063
1165
|
status: roadmapStatusSchema.optional().describe("Filter by status"),
|
|
1064
1166
|
horizon: horizonSchema.optional().describe("Filter by planning horizon"),
|
|
1065
|
-
|
|
1066
|
-
|
|
1167
|
+
phase: z12.string().optional().describe("Filter by phase"),
|
|
1168
|
+
phaseStep: z12.string().optional().describe("Filter by phase step"),
|
|
1169
|
+
limit: z12.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
|
|
1170
|
+
offset: z12.number().int().min(0).optional().describe("Number of items to skip (default 0)")
|
|
1067
1171
|
}
|
|
1068
1172
|
}, async ({
|
|
1069
1173
|
query,
|
|
1070
1174
|
status,
|
|
1071
1175
|
horizon,
|
|
1176
|
+
phase,
|
|
1177
|
+
phaseStep,
|
|
1072
1178
|
limit,
|
|
1073
1179
|
offset
|
|
1074
1180
|
}) => {
|
|
1075
1181
|
const client2 = getApiClient();
|
|
1076
|
-
const response = await client2.listRoadmaps({
|
|
1182
|
+
const response = await client2.listRoadmaps({
|
|
1183
|
+
limit,
|
|
1184
|
+
offset,
|
|
1185
|
+
horizon,
|
|
1186
|
+
query,
|
|
1187
|
+
phase,
|
|
1188
|
+
phaseStep
|
|
1189
|
+
});
|
|
1077
1190
|
let roadmaps = response.items;
|
|
1078
1191
|
if (status) {
|
|
1079
1192
|
roadmaps = roadmaps.filter((r) => r.status === status);
|
|
@@ -1088,6 +1201,8 @@ function registerSearchRoadmaps(server) {
|
|
|
1088
1201
|
title: r.title,
|
|
1089
1202
|
status: r.status,
|
|
1090
1203
|
horizon: r.horizon,
|
|
1204
|
+
phase: r.phase,
|
|
1205
|
+
phaseStep: r.phaseStep,
|
|
1091
1206
|
value: r.value,
|
|
1092
1207
|
effort: r.effort,
|
|
1093
1208
|
order: r.order
|
|
@@ -1103,7 +1218,7 @@ function registerGetRoadmap(server) {
|
|
|
1103
1218
|
server.registerTool("get_roadmap", {
|
|
1104
1219
|
description: "Get full details of a roadmap item including PRD, wireframes, brainstorm media, linked features, epics, and stories.",
|
|
1105
1220
|
inputSchema: {
|
|
1106
|
-
id:
|
|
1221
|
+
id: z12.string().describe("The UUID of the roadmap item")
|
|
1107
1222
|
}
|
|
1108
1223
|
}, async ({ id }) => {
|
|
1109
1224
|
const client2 = getApiClient();
|
|
@@ -1157,7 +1272,7 @@ function registerSearchFeatures(server) {
|
|
|
1157
1272
|
server.registerTool("search_features", {
|
|
1158
1273
|
description: "Search for features and feature areas by name. Returns a list of matching features with basic info.",
|
|
1159
1274
|
inputSchema: {
|
|
1160
|
-
query:
|
|
1275
|
+
query: z12.string().optional().describe("Search query to match against name"),
|
|
1161
1276
|
type: featureTypeSchema.optional().describe("Filter by type (feature or area)")
|
|
1162
1277
|
}
|
|
1163
1278
|
}, async ({ query, type }) => {
|
|
@@ -1189,7 +1304,7 @@ function registerGetFeature(server) {
|
|
|
1189
1304
|
server.registerTool("get_feature", {
|
|
1190
1305
|
description: "Get full details of a feature including outcomes, child features, and linked roadmap items.",
|
|
1191
1306
|
inputSchema: {
|
|
1192
|
-
id:
|
|
1307
|
+
id: z12.string().describe("The UUID of the feature")
|
|
1193
1308
|
}
|
|
1194
1309
|
}, async ({ id }) => {
|
|
1195
1310
|
const client2 = getApiClient();
|
|
@@ -1228,7 +1343,7 @@ function registerSearchIdeas(server) {
|
|
|
1228
1343
|
server.registerTool("search_ideas", {
|
|
1229
1344
|
description: "Search for ideas by title or status. Returns a list of matching ideas with basic info.",
|
|
1230
1345
|
inputSchema: {
|
|
1231
|
-
query:
|
|
1346
|
+
query: z12.string().optional().describe("Search query to match against title or description"),
|
|
1232
1347
|
status: ideaStatusSchema.optional().describe("Filter by status")
|
|
1233
1348
|
}
|
|
1234
1349
|
}, async ({ query, status }) => {
|
|
@@ -1328,9 +1443,9 @@ function registerCaptureIdea(server) {
|
|
|
1328
1443
|
server.registerTool("capture_idea", {
|
|
1329
1444
|
description: "Quickly capture a new idea. Ideas are suggestions that can later be reviewed and potentially converted to roadmap items.",
|
|
1330
1445
|
inputSchema: {
|
|
1331
|
-
title:
|
|
1332
|
-
description:
|
|
1333
|
-
source:
|
|
1446
|
+
title: z12.string().describe("Title of the idea"),
|
|
1447
|
+
description: z12.string().optional().describe("Detailed description of the idea"),
|
|
1448
|
+
source: z12.string().optional().describe('Source of the idea (defaults to "claude-code")')
|
|
1334
1449
|
}
|
|
1335
1450
|
}, async ({
|
|
1336
1451
|
title,
|
|
@@ -1367,19 +1482,23 @@ function registerCreateRoadmapItem(server) {
|
|
|
1367
1482
|
server.registerTool("create_roadmap_item", {
|
|
1368
1483
|
description: "Create a new roadmap item. Use this to add planned work to the roadmap.",
|
|
1369
1484
|
inputSchema: {
|
|
1370
|
-
title:
|
|
1485
|
+
title: z12.string().describe("Title of the roadmap item"),
|
|
1371
1486
|
status: roadmapStatusSchema.optional().describe('Status (defaults to "not_started")'),
|
|
1372
1487
|
horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
|
|
1373
|
-
|
|
1488
|
+
phase: z12.string().optional().describe('Initial phase key (e.g., "brainstorm", "prd", "design")'),
|
|
1489
|
+
phaseStep: z12.string().optional().describe('Initial step within phase (e.g., "not_started", "drafting")'),
|
|
1490
|
+
initiativeId: z12.string().optional().describe("UUID of initiative to link this item to on creation"),
|
|
1374
1491
|
dateGranularity: dateGranularitySchema2.optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
|
|
1375
|
-
dateValue:
|
|
1492
|
+
dateValue: z12.string().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
|
|
1376
1493
|
targetGranularity: dateGranularitySchema2.optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
|
|
1377
|
-
targetValue:
|
|
1494
|
+
targetValue: z12.string().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
|
|
1378
1495
|
}
|
|
1379
1496
|
}, async ({
|
|
1380
1497
|
title,
|
|
1381
1498
|
status,
|
|
1382
1499
|
horizon,
|
|
1500
|
+
phase,
|
|
1501
|
+
phaseStep,
|
|
1383
1502
|
initiativeId,
|
|
1384
1503
|
dateGranularity,
|
|
1385
1504
|
dateValue,
|
|
@@ -1392,6 +1511,10 @@ function registerCreateRoadmapItem(server) {
|
|
|
1392
1511
|
status: status ?? "not_started",
|
|
1393
1512
|
horizon: horizon ?? "inbox"
|
|
1394
1513
|
};
|
|
1514
|
+
if (phase)
|
|
1515
|
+
createData.phase = phase;
|
|
1516
|
+
if (phaseStep)
|
|
1517
|
+
createData.phaseStep = phaseStep;
|
|
1395
1518
|
if (initiativeId) {
|
|
1396
1519
|
createData.initiativeId = initiativeId;
|
|
1397
1520
|
}
|
|
@@ -1419,6 +1542,8 @@ function registerCreateRoadmapItem(server) {
|
|
|
1419
1542
|
title: roadmap2.title,
|
|
1420
1543
|
status: roadmap2.status,
|
|
1421
1544
|
horizon: roadmap2.horizon,
|
|
1545
|
+
phase: roadmap2.phase,
|
|
1546
|
+
phaseStep: roadmap2.phaseStep,
|
|
1422
1547
|
date: roadmap2.date,
|
|
1423
1548
|
target: roadmap2.target
|
|
1424
1549
|
}
|
|
@@ -1428,34 +1553,38 @@ function registerCreateRoadmapItem(server) {
|
|
|
1428
1553
|
};
|
|
1429
1554
|
});
|
|
1430
1555
|
}
|
|
1431
|
-
var effortSizeSchema =
|
|
1556
|
+
var effortSizeSchema = z12.enum(["xs", "s", "m", "l", "xl"]);
|
|
1432
1557
|
function registerUpdateRoadmapItem(server) {
|
|
1433
1558
|
server.registerTool("update_roadmap_item", {
|
|
1434
|
-
description: "Update an existing roadmap item. Can update title, status, horizon, value, effort, order, prompt, initiative link, target date, or brainstorm notes.",
|
|
1559
|
+
description: "Update an existing roadmap item. Can update title, status, horizon, value, effort, order, prompt, initiative link, target date, phase, phaseStep, or brainstorm notes.",
|
|
1435
1560
|
inputSchema: {
|
|
1436
|
-
id:
|
|
1437
|
-
title:
|
|
1561
|
+
id: z12.string().describe("The UUID of the roadmap item to update"),
|
|
1562
|
+
title: z12.string().optional().describe("New title"),
|
|
1438
1563
|
status: roadmapStatusSchema.optional().describe("New status"),
|
|
1439
1564
|
horizon: horizonSchema.optional().describe("New planning horizon"),
|
|
1440
|
-
|
|
1565
|
+
phase: z12.string().optional().describe('Current phase key (e.g., "prd", "design", "build")'),
|
|
1566
|
+
phaseStep: z12.string().optional().describe('Current step within phase (e.g., "drafting", "needs_review", "approved")'),
|
|
1567
|
+
value: z12.number().int().min(1).max(3).nullable().optional().describe("Value rating (1-3 stars, where 3 is highest value)"),
|
|
1441
1568
|
effort: effortSizeSchema.nullable().optional().describe("Effort estimate (xs=extra small, s=small, m=medium, l=large, xl=extra large)"),
|
|
1442
|
-
order:
|
|
1443
|
-
initiativeId:
|
|
1444
|
-
designDescription:
|
|
1445
|
-
planDescription:
|
|
1446
|
-
buildDescription:
|
|
1447
|
-
releaseDescription:
|
|
1448
|
-
prompt:
|
|
1569
|
+
order: z12.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)"),
|
|
1570
|
+
initiativeId: z12.string().nullable().optional().describe("UUID to link item to initiative, or null to unlink from any initiative"),
|
|
1571
|
+
designDescription: z12.string().nullable().optional().describe("Description for the Design phase"),
|
|
1572
|
+
planDescription: z12.string().nullable().optional().describe("Description for the Planning phase"),
|
|
1573
|
+
buildDescription: z12.string().nullable().optional().describe("Description for the Build phase"),
|
|
1574
|
+
releaseDescription: z12.string().nullable().optional().describe("Description for the Release phase"),
|
|
1575
|
+
prompt: z12.string().nullable().optional().describe("Build prompt for the roadmap item"),
|
|
1449
1576
|
dateGranularity: dateGranularitySchema2.nullable().optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
|
|
1450
|
-
dateValue:
|
|
1577
|
+
dateValue: z12.string().nullable().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
|
|
1451
1578
|
targetGranularity: dateGranularitySchema2.nullable().optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
|
|
1452
|
-
targetValue:
|
|
1579
|
+
targetValue: z12.string().nullable().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
|
|
1453
1580
|
}
|
|
1454
1581
|
}, async ({
|
|
1455
1582
|
id,
|
|
1456
1583
|
title,
|
|
1457
1584
|
status,
|
|
1458
1585
|
horizon,
|
|
1586
|
+
phase,
|
|
1587
|
+
phaseStep,
|
|
1459
1588
|
value,
|
|
1460
1589
|
effort,
|
|
1461
1590
|
order,
|
|
@@ -1478,6 +1607,10 @@ function registerUpdateRoadmapItem(server) {
|
|
|
1478
1607
|
updates.status = status;
|
|
1479
1608
|
if (horizon !== undefined)
|
|
1480
1609
|
updates.horizon = horizon;
|
|
1610
|
+
if (phase !== undefined)
|
|
1611
|
+
updates.phase = phase;
|
|
1612
|
+
if (phaseStep !== undefined)
|
|
1613
|
+
updates.phaseStep = phaseStep;
|
|
1481
1614
|
if (value !== undefined)
|
|
1482
1615
|
updates.value = value;
|
|
1483
1616
|
if (effort !== undefined)
|
|
@@ -1535,6 +1668,8 @@ function registerUpdateRoadmapItem(server) {
|
|
|
1535
1668
|
title: roadmap2.title,
|
|
1536
1669
|
status: roadmap2.status,
|
|
1537
1670
|
horizon: roadmap2.horizon,
|
|
1671
|
+
phase: roadmap2.phase,
|
|
1672
|
+
phaseStep: roadmap2.phaseStep,
|
|
1538
1673
|
value: roadmap2.value,
|
|
1539
1674
|
effort: roadmap2.effort,
|
|
1540
1675
|
order: roadmap2.order,
|
|
@@ -1552,12 +1687,12 @@ function registerAddFeature(server) {
|
|
|
1552
1687
|
server.registerTool("add_feature", {
|
|
1553
1688
|
description: "Create a new feature with optional outcomes. Features represent capabilities or functionality areas.",
|
|
1554
1689
|
inputSchema: {
|
|
1555
|
-
name:
|
|
1556
|
-
description:
|
|
1690
|
+
name: z12.string().describe("Name of the feature"),
|
|
1691
|
+
description: z12.string().optional().describe("Description of the feature"),
|
|
1557
1692
|
type: featureTypeSchema.optional().describe('Type - "feature" for specific functionality, "area" for grouping (defaults to "feature")'),
|
|
1558
|
-
parentId:
|
|
1559
|
-
outcomes:
|
|
1560
|
-
linkToRoadmapId:
|
|
1693
|
+
parentId: z12.string().optional().describe("UUID of parent feature/area to nest under"),
|
|
1694
|
+
outcomes: z12.array(z12.string()).optional().describe("List of expected outcomes for this feature"),
|
|
1695
|
+
linkToRoadmapId: z12.string().optional().describe("UUID of roadmap item to link this feature to")
|
|
1561
1696
|
}
|
|
1562
1697
|
}, async ({
|
|
1563
1698
|
name,
|
|
@@ -1604,10 +1739,10 @@ function registerSavePrd(server) {
|
|
|
1604
1739
|
server.registerTool("save_prd", {
|
|
1605
1740
|
description: "Save or update the PRD (Product Requirements Document) content for a roadmap item. Content should be markdown.",
|
|
1606
1741
|
inputSchema: {
|
|
1607
|
-
roadmapId:
|
|
1608
|
-
what:
|
|
1609
|
-
why:
|
|
1610
|
-
outcomes:
|
|
1742
|
+
roadmapId: z12.string().describe("The UUID of the roadmap item"),
|
|
1743
|
+
what: z12.string().nullable().describe("What is being built - the feature description"),
|
|
1744
|
+
why: z12.string().nullable().describe("Why this is being built - the business justification"),
|
|
1745
|
+
outcomes: z12.array(z12.string()).optional().describe("List of expected outcomes/success criteria")
|
|
1611
1746
|
}
|
|
1612
1747
|
}, async ({
|
|
1613
1748
|
roadmapId,
|
|
@@ -1645,8 +1780,8 @@ function registerUpdateBrainstormNotes(server) {
|
|
|
1645
1780
|
server.registerTool("update_brainstorm_notes", {
|
|
1646
1781
|
description: "Update the brainstorm notes for a roadmap item. Use this to capture ideas, questions, and research notes.",
|
|
1647
1782
|
inputSchema: {
|
|
1648
|
-
roadmapId:
|
|
1649
|
-
notes:
|
|
1783
|
+
roadmapId: z12.string().describe("The UUID of the roadmap item"),
|
|
1784
|
+
notes: z12.string().describe("The brainstorm notes content")
|
|
1650
1785
|
}
|
|
1651
1786
|
}, async ({ roadmapId, notes }) => {
|
|
1652
1787
|
const client2 = getApiClient();
|
|
@@ -1675,7 +1810,7 @@ function registerDeleteRoadmapItem(server) {
|
|
|
1675
1810
|
server.registerTool("delete_roadmap_item", {
|
|
1676
1811
|
description: "Delete a roadmap item. This is a soft delete - the item can potentially be recovered.",
|
|
1677
1812
|
inputSchema: {
|
|
1678
|
-
id:
|
|
1813
|
+
id: z12.string().describe("The UUID of the roadmap item to delete")
|
|
1679
1814
|
}
|
|
1680
1815
|
}, async ({ id }) => {
|
|
1681
1816
|
const client2 = getApiClient();
|
|
@@ -1697,9 +1832,9 @@ function registerReorderRoadmaps(server) {
|
|
|
1697
1832
|
server.registerTool("reorder_roadmaps", {
|
|
1698
1833
|
description: "Bulk reorder roadmap items by setting their order values. Use this to prioritize and organize the roadmap. Lower order values appear first.",
|
|
1699
1834
|
inputSchema: {
|
|
1700
|
-
items:
|
|
1701
|
-
id:
|
|
1702
|
-
order:
|
|
1835
|
+
items: z12.array(z12.object({
|
|
1836
|
+
id: z12.string().describe("The UUID of the roadmap item"),
|
|
1837
|
+
order: z12.number().int().min(0).describe("The new order value (0-based, lower = higher priority)")
|
|
1703
1838
|
})).describe("Array of roadmap items with their new order values")
|
|
1704
1839
|
}
|
|
1705
1840
|
}, async ({ items }) => {
|
|
@@ -1723,10 +1858,10 @@ function registerUpdateFeature(server) {
|
|
|
1723
1858
|
server.registerTool("update_feature", {
|
|
1724
1859
|
description: "Update an existing feature. Can update name, type, or parent.",
|
|
1725
1860
|
inputSchema: {
|
|
1726
|
-
id:
|
|
1727
|
-
name:
|
|
1861
|
+
id: z12.string().describe("The UUID of the feature to update"),
|
|
1862
|
+
name: z12.string().optional().describe("New name for the feature"),
|
|
1728
1863
|
type: featureTypeSchema.optional().describe('New type - "feature" or "area"'),
|
|
1729
|
-
parentId:
|
|
1864
|
+
parentId: z12.string().nullable().optional().describe("New parent feature/area UUID, or null to move to root")
|
|
1730
1865
|
}
|
|
1731
1866
|
}, async ({
|
|
1732
1867
|
id,
|
|
@@ -1765,7 +1900,7 @@ function registerDeleteFeature(server) {
|
|
|
1765
1900
|
server.registerTool("delete_feature", {
|
|
1766
1901
|
description: "Delete a feature. This is a soft delete that also deletes all child features.",
|
|
1767
1902
|
inputSchema: {
|
|
1768
|
-
id:
|
|
1903
|
+
id: z12.string().describe("The UUID of the feature to delete")
|
|
1769
1904
|
}
|
|
1770
1905
|
}, async ({ id }) => {
|
|
1771
1906
|
const client2 = getApiClient();
|
|
@@ -1787,7 +1922,7 @@ function registerGetIdea(server) {
|
|
|
1787
1922
|
server.registerTool("get_idea", {
|
|
1788
1923
|
description: "Get full details of a single idea by ID.",
|
|
1789
1924
|
inputSchema: {
|
|
1790
|
-
id:
|
|
1925
|
+
id: z12.string().describe("The UUID of the idea")
|
|
1791
1926
|
}
|
|
1792
1927
|
}, async ({ id }) => {
|
|
1793
1928
|
const client2 = getApiClient();
|
|
@@ -1816,12 +1951,12 @@ function registerUpdateIdea(server) {
|
|
|
1816
1951
|
server.registerTool("update_idea", {
|
|
1817
1952
|
description: "Update an existing idea. Can update title, description, status, value, or effort.",
|
|
1818
1953
|
inputSchema: {
|
|
1819
|
-
id:
|
|
1820
|
-
title:
|
|
1821
|
-
description:
|
|
1954
|
+
id: z12.string().describe("The UUID of the idea to update"),
|
|
1955
|
+
title: z12.string().optional().describe("New title"),
|
|
1956
|
+
description: z12.string().nullable().optional().describe("New description"),
|
|
1822
1957
|
status: ideaStatusSchema.optional().describe("New status"),
|
|
1823
|
-
value:
|
|
1824
|
-
effort:
|
|
1958
|
+
value: z12.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated value"),
|
|
1959
|
+
effort: z12.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated effort")
|
|
1825
1960
|
}
|
|
1826
1961
|
}, async ({
|
|
1827
1962
|
id,
|
|
@@ -1868,7 +2003,7 @@ function registerDeleteIdea(server) {
|
|
|
1868
2003
|
server.registerTool("delete_idea", {
|
|
1869
2004
|
description: "Delete an idea. This is a soft delete.",
|
|
1870
2005
|
inputSchema: {
|
|
1871
|
-
id:
|
|
2006
|
+
id: z12.string().describe("The UUID of the idea to delete")
|
|
1872
2007
|
}
|
|
1873
2008
|
}, async ({ id }) => {
|
|
1874
2009
|
const client2 = getApiClient();
|
|
@@ -1907,8 +2042,8 @@ function registerUpdateStrategy(server) {
|
|
|
1907
2042
|
server.registerTool("update_strategy", {
|
|
1908
2043
|
description: "Update the organization strategy. Can update vision, mission, or both. Use this to set or refine the high-level direction.",
|
|
1909
2044
|
inputSchema: {
|
|
1910
|
-
vision:
|
|
1911
|
-
mission:
|
|
2045
|
+
vision: z12.string().nullable().optional().describe("The vision statement - where the product is headed"),
|
|
2046
|
+
mission: z12.string().nullable().optional().describe("The mission statement - why the product exists")
|
|
1912
2047
|
}
|
|
1913
2048
|
}, async ({ vision, mission }) => {
|
|
1914
2049
|
const client2 = getApiClient();
|
|
@@ -1956,8 +2091,8 @@ function registerCreateScenario(server) {
|
|
|
1956
2091
|
server.registerTool("create_scenario", {
|
|
1957
2092
|
description: "Create a new user scenario. Scenarios describe user workflows and how they accomplish goals.",
|
|
1958
2093
|
inputSchema: {
|
|
1959
|
-
title:
|
|
1960
|
-
description:
|
|
2094
|
+
title: z12.string().describe('Title of the scenario (e.g., "User creates their first roadmap")'),
|
|
2095
|
+
description: z12.string().nullable().optional().describe("Detailed description of the scenario workflow")
|
|
1961
2096
|
}
|
|
1962
2097
|
}, async ({ title, description }) => {
|
|
1963
2098
|
const client2 = getApiClient();
|
|
@@ -1986,9 +2121,9 @@ function registerUpdateScenario(server) {
|
|
|
1986
2121
|
server.registerTool("update_scenario", {
|
|
1987
2122
|
description: "Update an existing scenario.",
|
|
1988
2123
|
inputSchema: {
|
|
1989
|
-
id:
|
|
1990
|
-
title:
|
|
1991
|
-
description:
|
|
2124
|
+
id: z12.string().describe("The UUID of the scenario to update"),
|
|
2125
|
+
title: z12.string().optional().describe("New title"),
|
|
2126
|
+
description: z12.string().nullable().optional().describe("New description")
|
|
1992
2127
|
}
|
|
1993
2128
|
}, async ({
|
|
1994
2129
|
id,
|
|
@@ -2023,7 +2158,7 @@ function registerDeleteScenario(server) {
|
|
|
2023
2158
|
server.registerTool("delete_scenario", {
|
|
2024
2159
|
description: "Delete a scenario. This is a soft delete.",
|
|
2025
2160
|
inputSchema: {
|
|
2026
|
-
id:
|
|
2161
|
+
id: z12.string().describe("The UUID of the scenario to delete")
|
|
2027
2162
|
}
|
|
2028
2163
|
}, async ({ id }) => {
|
|
2029
2164
|
const client2 = getApiClient();
|
|
@@ -2038,7 +2173,7 @@ function registerDeleteScenario(server) {
|
|
|
2038
2173
|
};
|
|
2039
2174
|
});
|
|
2040
2175
|
}
|
|
2041
|
-
var productTypeSchema2 =
|
|
2176
|
+
var productTypeSchema2 = z12.enum([
|
|
2042
2177
|
"brand",
|
|
2043
2178
|
"product",
|
|
2044
2179
|
"app",
|
|
@@ -2051,8 +2186,8 @@ function registerCreateProduct(server) {
|
|
|
2051
2186
|
description: "Create a new product, app, brand, or service. Products represent what the organization builds and offers.",
|
|
2052
2187
|
inputSchema: {
|
|
2053
2188
|
type: productTypeSchema2.describe("Type of product"),
|
|
2054
|
-
name:
|
|
2055
|
-
parentId:
|
|
2189
|
+
name: z12.string().describe("Name of the product"),
|
|
2190
|
+
parentId: z12.string().nullable().optional().describe("UUID of parent product to nest under")
|
|
2056
2191
|
}
|
|
2057
2192
|
}, async ({
|
|
2058
2193
|
type,
|
|
@@ -2087,9 +2222,9 @@ function registerUpdateProduct(server) {
|
|
|
2087
2222
|
server.registerTool("update_product", {
|
|
2088
2223
|
description: "Update an existing product.",
|
|
2089
2224
|
inputSchema: {
|
|
2090
|
-
id:
|
|
2091
|
-
name:
|
|
2092
|
-
parentId:
|
|
2225
|
+
id: z12.string().describe("The UUID of the product to update"),
|
|
2226
|
+
name: z12.string().optional().describe("New name"),
|
|
2227
|
+
parentId: z12.string().nullable().optional().describe("New parent product UUID, or null to move to root")
|
|
2093
2228
|
}
|
|
2094
2229
|
}, async ({ id, name, parentId }) => {
|
|
2095
2230
|
const client2 = getApiClient();
|
|
@@ -2121,7 +2256,7 @@ function registerDeleteProduct(server) {
|
|
|
2121
2256
|
server.registerTool("delete_product", {
|
|
2122
2257
|
description: "Delete a product. This is a soft delete that also deletes all child products.",
|
|
2123
2258
|
inputSchema: {
|
|
2124
|
-
id:
|
|
2259
|
+
id: z12.string().describe("The UUID of the product to delete")
|
|
2125
2260
|
}
|
|
2126
2261
|
}, async ({ id }) => {
|
|
2127
2262
|
const client2 = getApiClient();
|
|
@@ -2144,7 +2279,7 @@ function registerGetProduct(server) {
|
|
|
2144
2279
|
server.registerTool("get_product", {
|
|
2145
2280
|
description: "Get full details of a product by ID, including its documentation (design system and ADRs).",
|
|
2146
2281
|
inputSchema: {
|
|
2147
|
-
id:
|
|
2282
|
+
id: z12.string().describe("The UUID of the product")
|
|
2148
2283
|
}
|
|
2149
2284
|
}, async ({ id }) => {
|
|
2150
2285
|
const client2 = getApiClient();
|
|
@@ -2181,7 +2316,7 @@ function registerSearchProducts(server) {
|
|
|
2181
2316
|
server.registerTool("search_products", {
|
|
2182
2317
|
description: "Search for products by name. Returns a list of matching products with basic info.",
|
|
2183
2318
|
inputSchema: {
|
|
2184
|
-
query:
|
|
2319
|
+
query: z12.string().optional().describe("Search query to match against product name"),
|
|
2185
2320
|
type: productTypeSchema2.optional().describe("Filter by product type")
|
|
2186
2321
|
}
|
|
2187
2322
|
}, async ({ query, type }) => {
|
|
@@ -2216,7 +2351,7 @@ function registerGetProductDocumentation(server) {
|
|
|
2216
2351
|
server.registerTool("get_product_documentation", {
|
|
2217
2352
|
description: "Get the documentation (design system and ADRs) for a product. Use this to read existing documentation before updating.",
|
|
2218
2353
|
inputSchema: {
|
|
2219
|
-
productId:
|
|
2354
|
+
productId: z12.string().describe("The UUID of the product")
|
|
2220
2355
|
}
|
|
2221
2356
|
}, async ({ productId }) => {
|
|
2222
2357
|
const client2 = getApiClient();
|
|
@@ -2244,9 +2379,9 @@ function registerUpdateProductDocumentation(server) {
|
|
|
2244
2379
|
server.registerTool("update_product_documentation", {
|
|
2245
2380
|
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.",
|
|
2246
2381
|
inputSchema: {
|
|
2247
|
-
productId:
|
|
2248
|
-
designSystem:
|
|
2249
|
-
adrs:
|
|
2382
|
+
productId: z12.string().describe("The UUID of the product"),
|
|
2383
|
+
designSystem: z12.string().nullable().optional().describe("Design system documentation - colors, typography, spacing, components. Pass null to clear."),
|
|
2384
|
+
adrs: z12.string().nullable().optional().describe("Architecture Decision Records - document key technical decisions. Pass null to clear.")
|
|
2250
2385
|
}
|
|
2251
2386
|
}, async ({
|
|
2252
2387
|
productId,
|
|
@@ -2283,8 +2418,8 @@ function registerCreateAudience(server) {
|
|
|
2283
2418
|
server.registerTool("create_audience", {
|
|
2284
2419
|
description: "Create a new audience member. Audiences represent who the product serves.",
|
|
2285
2420
|
inputSchema: {
|
|
2286
|
-
name:
|
|
2287
|
-
description:
|
|
2421
|
+
name: z12.string().describe('Name of the audience (e.g., "Product Manager", "End User")'),
|
|
2422
|
+
description: z12.string().nullable().optional().describe("Description of the audience")
|
|
2288
2423
|
}
|
|
2289
2424
|
}, async ({ name, description }) => {
|
|
2290
2425
|
const client2 = getApiClient();
|
|
@@ -2313,9 +2448,9 @@ function registerUpdateAudience(server) {
|
|
|
2313
2448
|
server.registerTool("update_audience", {
|
|
2314
2449
|
description: "Update an existing audience member.",
|
|
2315
2450
|
inputSchema: {
|
|
2316
|
-
id:
|
|
2317
|
-
name:
|
|
2318
|
-
description:
|
|
2451
|
+
id: z12.string().describe("The UUID of the audience to update"),
|
|
2452
|
+
name: z12.string().optional().describe("New name"),
|
|
2453
|
+
description: z12.string().nullable().optional().describe("New description")
|
|
2319
2454
|
}
|
|
2320
2455
|
}, async ({
|
|
2321
2456
|
id,
|
|
@@ -2350,7 +2485,7 @@ function registerDeleteAudience(server) {
|
|
|
2350
2485
|
server.registerTool("delete_audience", {
|
|
2351
2486
|
description: "Delete an audience member. This is a soft delete.",
|
|
2352
2487
|
inputSchema: {
|
|
2353
|
-
id:
|
|
2488
|
+
id: z12.string().describe("The UUID of the audience to delete")
|
|
2354
2489
|
}
|
|
2355
2490
|
}, async ({ id }) => {
|
|
2356
2491
|
const client2 = getApiClient();
|
|
@@ -2392,9 +2527,9 @@ function registerGetHistory(server) {
|
|
|
2392
2527
|
server.registerTool("get_history", {
|
|
2393
2528
|
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.",
|
|
2394
2529
|
inputSchema: {
|
|
2395
|
-
startDate:
|
|
2396
|
-
endDate:
|
|
2397
|
-
entityType:
|
|
2530
|
+
startDate: z12.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
|
|
2531
|
+
endDate: z12.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format"),
|
|
2532
|
+
entityType: z12.enum([
|
|
2398
2533
|
"roadmap",
|
|
2399
2534
|
"feature",
|
|
2400
2535
|
"idea",
|
|
@@ -2426,8 +2561,8 @@ function registerGetHistorySummary(server) {
|
|
|
2426
2561
|
server.registerTool("get_history_summary", {
|
|
2427
2562
|
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.",
|
|
2428
2563
|
inputSchema: {
|
|
2429
|
-
startDate:
|
|
2430
|
-
endDate:
|
|
2564
|
+
startDate: z12.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
|
|
2565
|
+
endDate: z12.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format")
|
|
2431
2566
|
}
|
|
2432
2567
|
}, async ({ startDate, endDate }) => {
|
|
2433
2568
|
const client2 = getApiClient();
|
|
@@ -2446,13 +2581,13 @@ function registerCreateStatusUpdate(server) {
|
|
|
2446
2581
|
server.registerTool("create_status_update", {
|
|
2447
2582
|
description: "Create a new status report. Use this after generating the report content from history events.",
|
|
2448
2583
|
inputSchema: {
|
|
2449
|
-
startDate:
|
|
2450
|
-
endDate:
|
|
2451
|
-
content:
|
|
2452
|
-
title:
|
|
2453
|
-
items:
|
|
2454
|
-
roadmapItemId:
|
|
2455
|
-
status:
|
|
2584
|
+
startDate: z12.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period start date in YYYY-MM-DD format"),
|
|
2585
|
+
endDate: z12.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period end date in YYYY-MM-DD format"),
|
|
2586
|
+
content: z12.string().describe("The markdown content of the status report"),
|
|
2587
|
+
title: z12.string().optional().describe("Optional title for the report"),
|
|
2588
|
+
items: z12.array(z12.object({
|
|
2589
|
+
roadmapItemId: z12.string().describe("UUID of the roadmap item"),
|
|
2590
|
+
status: z12.string().describe("Status of the item at report creation time")
|
|
2456
2591
|
})).optional().describe("Roadmap items to include in the report snapshot")
|
|
2457
2592
|
}
|
|
2458
2593
|
}, async ({
|
|
@@ -2493,18 +2628,18 @@ function registerSaveStories(server) {
|
|
|
2493
2628
|
server.registerTool("save_stories", {
|
|
2494
2629
|
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.",
|
|
2495
2630
|
inputSchema: {
|
|
2496
|
-
roadmapId:
|
|
2497
|
-
epics:
|
|
2498
|
-
title:
|
|
2499
|
-
description:
|
|
2500
|
-
stories:
|
|
2501
|
-
title:
|
|
2502
|
-
description:
|
|
2631
|
+
roadmapId: z12.string().uuid().describe("The UUID of the roadmap item"),
|
|
2632
|
+
epics: z12.array(z12.object({
|
|
2633
|
+
title: z12.string().min(1).describe("Title of the epic"),
|
|
2634
|
+
description: z12.string().nullable().optional().describe("Description of the epic"),
|
|
2635
|
+
stories: z12.array(z12.object({
|
|
2636
|
+
title: z12.string().min(1).describe("Title of the story"),
|
|
2637
|
+
description: z12.string().nullable().optional().describe("Description of the story")
|
|
2503
2638
|
})).optional().describe("Stories within this epic")
|
|
2504
2639
|
})).optional().describe("List of epics with their nested stories"),
|
|
2505
|
-
stories:
|
|
2506
|
-
title:
|
|
2507
|
-
description:
|
|
2640
|
+
stories: z12.array(z12.object({
|
|
2641
|
+
title: z12.string().min(1).describe("Title of the story"),
|
|
2642
|
+
description: z12.string().nullable().optional().describe("Description of the story")
|
|
2508
2643
|
})).optional().describe("List of standalone stories (not part of any epic)")
|
|
2509
2644
|
}
|
|
2510
2645
|
}, async ({
|
|
@@ -2536,10 +2671,10 @@ function registerUploadWireframe(server) {
|
|
|
2536
2671
|
server.registerTool("upload_wireframe", {
|
|
2537
2672
|
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.",
|
|
2538
2673
|
inputSchema: {
|
|
2539
|
-
roadmapId:
|
|
2540
|
-
filePath:
|
|
2541
|
-
description:
|
|
2542
|
-
outcomeIds:
|
|
2674
|
+
roadmapId: z12.string().describe("The UUID of the roadmap item"),
|
|
2675
|
+
filePath: z12.string().describe("Absolute path to the image file on disk"),
|
|
2676
|
+
description: z12.string().optional().describe("Optional description of the wireframe"),
|
|
2677
|
+
outcomeIds: z12.array(z12.string()).optional().describe("Optional array of PRD outcome IDs this wireframe addresses")
|
|
2543
2678
|
}
|
|
2544
2679
|
}, async ({
|
|
2545
2680
|
roadmapId,
|
|
@@ -2593,9 +2728,9 @@ function registerUpdateWireframe(server) {
|
|
|
2593
2728
|
server.registerTool("update_wireframe", {
|
|
2594
2729
|
description: "Update a wireframe's description or outcome tags.",
|
|
2595
2730
|
inputSchema: {
|
|
2596
|
-
id:
|
|
2597
|
-
description:
|
|
2598
|
-
outcomeIds:
|
|
2731
|
+
id: z12.string().describe("The UUID of the wireframe"),
|
|
2732
|
+
description: z12.string().nullable().optional().describe("New description for the wireframe"),
|
|
2733
|
+
outcomeIds: z12.array(z12.string()).optional().describe("Array of PRD outcome IDs this wireframe addresses (replaces existing)")
|
|
2599
2734
|
}
|
|
2600
2735
|
}, async ({
|
|
2601
2736
|
id,
|
|
@@ -2631,7 +2766,7 @@ function registerDeleteWireframe(server) {
|
|
|
2631
2766
|
server.registerTool("delete_wireframe", {
|
|
2632
2767
|
description: "Delete a wireframe (soft delete).",
|
|
2633
2768
|
inputSchema: {
|
|
2634
|
-
id:
|
|
2769
|
+
id: z12.string().describe("The UUID of the wireframe to delete")
|
|
2635
2770
|
}
|
|
2636
2771
|
}, async ({ id }) => {
|
|
2637
2772
|
const client2 = getApiClient();
|
|
@@ -2650,9 +2785,9 @@ function registerUploadBrainstormMedia(server) {
|
|
|
2650
2785
|
server.registerTool("upload_brainstorm_media", {
|
|
2651
2786
|
description: "Upload an image or video to a roadmap item's brainstorming section. Returns a curl command to execute for the upload.",
|
|
2652
2787
|
inputSchema: {
|
|
2653
|
-
roadmapId:
|
|
2654
|
-
filePath:
|
|
2655
|
-
description:
|
|
2788
|
+
roadmapId: z12.string().describe("The UUID of the roadmap item"),
|
|
2789
|
+
filePath: z12.string().describe("Absolute path to the image or video file on disk"),
|
|
2790
|
+
description: z12.string().optional().describe("Optional description of the media")
|
|
2656
2791
|
}
|
|
2657
2792
|
}, async ({
|
|
2658
2793
|
roadmapId,
|
|
@@ -2704,8 +2839,8 @@ function registerUpdateBrainstormMedia(server) {
|
|
|
2704
2839
|
server.registerTool("update_brainstorm_media", {
|
|
2705
2840
|
description: "Update a brainstorm media item's description.",
|
|
2706
2841
|
inputSchema: {
|
|
2707
|
-
id:
|
|
2708
|
-
description:
|
|
2842
|
+
id: z12.string().describe("The UUID of the brainstorm media"),
|
|
2843
|
+
description: z12.string().nullable().describe("New description for the media")
|
|
2709
2844
|
}
|
|
2710
2845
|
}, async ({ id, description }) => {
|
|
2711
2846
|
const client2 = getApiClient();
|
|
@@ -2729,7 +2864,7 @@ function registerDeleteBrainstormMedia(server) {
|
|
|
2729
2864
|
server.registerTool("delete_brainstorm_media", {
|
|
2730
2865
|
description: "Delete a brainstorm media item (soft delete).",
|
|
2731
2866
|
inputSchema: {
|
|
2732
|
-
id:
|
|
2867
|
+
id: z12.string().describe("The UUID of the brainstorm media to delete")
|
|
2733
2868
|
}
|
|
2734
2869
|
}, async ({ id }) => {
|
|
2735
2870
|
const client2 = getApiClient();
|
|
@@ -2748,9 +2883,9 @@ function registerUploadProductDesignMedia(server) {
|
|
|
2748
2883
|
server.registerTool("upload_product_design_media", {
|
|
2749
2884
|
description: "Upload an image or video to a product's design media section. Returns a curl command to execute for the upload.",
|
|
2750
2885
|
inputSchema: {
|
|
2751
|
-
productId:
|
|
2752
|
-
filePath:
|
|
2753
|
-
description:
|
|
2886
|
+
productId: z12.string().describe("The UUID of the product"),
|
|
2887
|
+
filePath: z12.string().describe("Absolute path to the image or video file on disk"),
|
|
2888
|
+
description: z12.string().optional().describe("Optional description of the media")
|
|
2754
2889
|
}
|
|
2755
2890
|
}, async ({
|
|
2756
2891
|
productId,
|
|
@@ -2803,9 +2938,9 @@ function registerUpdateProductDesignMedia(server) {
|
|
|
2803
2938
|
server.registerTool("update_product_design_media", {
|
|
2804
2939
|
description: "Update a product design media item's description.",
|
|
2805
2940
|
inputSchema: {
|
|
2806
|
-
productId:
|
|
2807
|
-
mediaId:
|
|
2808
|
-
description:
|
|
2941
|
+
productId: z12.string().describe("The UUID of the product"),
|
|
2942
|
+
mediaId: z12.string().describe("The UUID of the design media"),
|
|
2943
|
+
description: z12.string().nullable().describe("New description for the media")
|
|
2809
2944
|
}
|
|
2810
2945
|
}, async ({
|
|
2811
2946
|
productId,
|
|
@@ -2833,8 +2968,8 @@ function registerDeleteProductDesignMedia(server) {
|
|
|
2833
2968
|
server.registerTool("delete_product_design_media", {
|
|
2834
2969
|
description: "Delete a product design media item (soft delete).",
|
|
2835
2970
|
inputSchema: {
|
|
2836
|
-
productId:
|
|
2837
|
-
mediaId:
|
|
2971
|
+
productId: z12.string().describe("The UUID of the product"),
|
|
2972
|
+
mediaId: z12.string().describe("The UUID of the design media to delete")
|
|
2838
2973
|
}
|
|
2839
2974
|
}, async ({ productId, mediaId }) => {
|
|
2840
2975
|
const client2 = getApiClient();
|
|
@@ -2856,8 +2991,8 @@ function registerUploadDesignWalkthrough(server) {
|
|
|
2856
2991
|
server.registerTool("upload_design_walkthrough", {
|
|
2857
2992
|
description: "Upload a walkthrough video to a roadmap item's design phase. Returns a curl command to execute for the upload.",
|
|
2858
2993
|
inputSchema: {
|
|
2859
|
-
roadmapId:
|
|
2860
|
-
filePath:
|
|
2994
|
+
roadmapId: z12.string().describe("The UUID of the roadmap item"),
|
|
2995
|
+
filePath: z12.string().describe("Absolute path to the video file on disk")
|
|
2861
2996
|
}
|
|
2862
2997
|
}, async ({ roadmapId, filePath }) => {
|
|
2863
2998
|
const client2 = getApiClient();
|
|
@@ -2899,8 +3034,8 @@ function registerUploadReleaseWalkthrough(server) {
|
|
|
2899
3034
|
server.registerTool("upload_release_walkthrough", {
|
|
2900
3035
|
description: "Upload a walkthrough video to a roadmap item's release phase. Returns a curl command to execute for the upload.",
|
|
2901
3036
|
inputSchema: {
|
|
2902
|
-
roadmapId:
|
|
2903
|
-
filePath:
|
|
3037
|
+
roadmapId: z12.string().describe("The UUID of the roadmap item"),
|
|
3038
|
+
filePath: z12.string().describe("Absolute path to the video file on disk")
|
|
2904
3039
|
}
|
|
2905
3040
|
}, async ({ roadmapId, filePath }) => {
|
|
2906
3041
|
const client2 = getApiClient();
|
|
@@ -2958,9 +3093,9 @@ function registerPublishPrototype(server) {
|
|
|
2958
3093
|
server.registerTool("publish_prototype", {
|
|
2959
3094
|
description: "Publish a local prototype folder to a shareable URL. Uploads all files from the folder and returns a time-limited shareable link.",
|
|
2960
3095
|
inputSchema: {
|
|
2961
|
-
roadmapId:
|
|
2962
|
-
folderPath:
|
|
2963
|
-
entryPoint:
|
|
3096
|
+
roadmapId: z12.string().uuid().describe("The UUID of the roadmap item to attach the prototype to"),
|
|
3097
|
+
folderPath: z12.string().describe("Absolute path to the local mockup folder"),
|
|
3098
|
+
entryPoint: z12.string().default("index.html").describe("Main HTML file to open (defaults to index.html)")
|
|
2964
3099
|
}
|
|
2965
3100
|
}, async ({
|
|
2966
3101
|
roadmapId,
|
|
@@ -3115,15 +3250,15 @@ Expires: ${expiryDate}`
|
|
|
3115
3250
|
};
|
|
3116
3251
|
});
|
|
3117
3252
|
}
|
|
3118
|
-
var dateGranularitySchema2 =
|
|
3253
|
+
var dateGranularitySchema2 = z12.enum(["day", "month", "quarter", "half-year", "year"]);
|
|
3119
3254
|
function registerSearchInitiatives(server) {
|
|
3120
3255
|
server.registerTool("search_initiatives", {
|
|
3121
3256
|
description: "Search for initiatives by title or filter by horizon. Returns a list of matching initiatives with item counts.",
|
|
3122
3257
|
inputSchema: {
|
|
3123
|
-
query:
|
|
3258
|
+
query: z12.string().optional().describe("Search query to match against title or description"),
|
|
3124
3259
|
horizon: horizonSchema.optional().describe("Filter by planning horizon"),
|
|
3125
|
-
limit:
|
|
3126
|
-
offset:
|
|
3260
|
+
limit: z12.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
|
|
3261
|
+
offset: z12.number().int().min(0).optional().describe("Number of items to skip (default 0)")
|
|
3127
3262
|
}
|
|
3128
3263
|
}, async ({
|
|
3129
3264
|
query,
|
|
@@ -3173,7 +3308,7 @@ function registerGetInitiative(server) {
|
|
|
3173
3308
|
server.registerTool("get_initiative", {
|
|
3174
3309
|
description: "Get full details of an initiative including all linked roadmap items.",
|
|
3175
3310
|
inputSchema: {
|
|
3176
|
-
id:
|
|
3311
|
+
id: z12.string().describe("The UUID of the initiative")
|
|
3177
3312
|
}
|
|
3178
3313
|
}, async ({ id }) => {
|
|
3179
3314
|
const client2 = getApiClient();
|
|
@@ -3192,12 +3327,12 @@ function registerCreateInitiative(server) {
|
|
|
3192
3327
|
server.registerTool("create_initiative", {
|
|
3193
3328
|
description: "Create a new initiative. Initiatives group related roadmap items for cross-functional coordination.",
|
|
3194
3329
|
inputSchema: {
|
|
3195
|
-
title:
|
|
3196
|
-
description:
|
|
3330
|
+
title: z12.string().describe("Title of the initiative"),
|
|
3331
|
+
description: z12.string().optional().describe("Description of the initiative (markdown)"),
|
|
3197
3332
|
horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
|
|
3198
3333
|
dateGranularity: dateGranularitySchema2.optional().describe("Target date granularity: day, month, quarter, half-year, or year"),
|
|
3199
|
-
dateValue:
|
|
3200
|
-
targetDate:
|
|
3334
|
+
dateValue: z12.string().optional().describe('Target date value matching granularity (e.g., "2024-Q1", "2024-03")'),
|
|
3335
|
+
targetDate: z12.string().optional().describe("Target date in YYYY-MM-DD format")
|
|
3201
3336
|
}
|
|
3202
3337
|
}, async ({
|
|
3203
3338
|
title,
|
|
@@ -3241,14 +3376,14 @@ function registerUpdateInitiative(server) {
|
|
|
3241
3376
|
server.registerTool("update_initiative", {
|
|
3242
3377
|
description: "Update an existing initiative.",
|
|
3243
3378
|
inputSchema: {
|
|
3244
|
-
id:
|
|
3245
|
-
title:
|
|
3246
|
-
description:
|
|
3379
|
+
id: z12.string().describe("The UUID of the initiative to update"),
|
|
3380
|
+
title: z12.string().optional().describe("New title"),
|
|
3381
|
+
description: z12.string().nullable().optional().describe("New description (null to clear)"),
|
|
3247
3382
|
horizon: horizonSchema.optional().describe("New planning horizon"),
|
|
3248
3383
|
dateGranularity: dateGranularitySchema2.nullable().optional().describe("New target date granularity (null to clear)"),
|
|
3249
|
-
dateValue:
|
|
3250
|
-
targetDate:
|
|
3251
|
-
order:
|
|
3384
|
+
dateValue: z12.string().nullable().optional().describe("New target date value (null to clear)"),
|
|
3385
|
+
targetDate: z12.string().nullable().optional().describe("New target date in YYYY-MM-DD format (null to clear)"),
|
|
3386
|
+
order: z12.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)")
|
|
3252
3387
|
}
|
|
3253
3388
|
}, async ({
|
|
3254
3389
|
id,
|
|
@@ -3303,7 +3438,7 @@ function registerDeleteInitiative(server) {
|
|
|
3303
3438
|
server.registerTool("delete_initiative", {
|
|
3304
3439
|
description: "Delete an initiative. This is a soft delete that also unlinks all roadmap items from the initiative.",
|
|
3305
3440
|
inputSchema: {
|
|
3306
|
-
id:
|
|
3441
|
+
id: z12.string().describe("The UUID of the initiative to delete")
|
|
3307
3442
|
}
|
|
3308
3443
|
}, async ({ id }) => {
|
|
3309
3444
|
const client2 = getApiClient();
|
|
@@ -3322,9 +3457,9 @@ function registerReorderInitiatives(server) {
|
|
|
3322
3457
|
server.registerTool("reorder_initiatives", {
|
|
3323
3458
|
description: "Bulk reorder initiatives by setting their order values. Lower order values appear first.",
|
|
3324
3459
|
inputSchema: {
|
|
3325
|
-
items:
|
|
3326
|
-
id:
|
|
3327
|
-
order:
|
|
3460
|
+
items: z12.array(z12.object({
|
|
3461
|
+
id: z12.string().describe("The UUID of the initiative"),
|
|
3462
|
+
order: z12.number().int().min(0).describe("The new order value (0-based)")
|
|
3328
3463
|
})).describe("Array of initiatives with their new order values")
|
|
3329
3464
|
}
|
|
3330
3465
|
}, async ({ items }) => {
|
|
@@ -3340,6 +3475,155 @@ function registerReorderInitiatives(server) {
|
|
|
3340
3475
|
};
|
|
3341
3476
|
});
|
|
3342
3477
|
}
|
|
3478
|
+
function registerSearchExports(server) {
|
|
3479
|
+
server.registerTool("search_exports", {
|
|
3480
|
+
description: "Search for export records by roadmap, external system, or entity. Returns a list of matching exports with pagination.",
|
|
3481
|
+
inputSchema: {
|
|
3482
|
+
roadmapId: z12.string().uuid().optional().describe("Filter by roadmap item ID"),
|
|
3483
|
+
externalSystem: z12.enum(["linear", "notion", "jira", "github"]).optional().describe("Filter by external system"),
|
|
3484
|
+
localEntityType: z12.enum(["roadmap", "prd", "epic", "story", "design"]).optional().describe("Filter by local entity type"),
|
|
3485
|
+
localEntityId: z12.string().uuid().optional().describe("Filter by local entity ID"),
|
|
3486
|
+
limit: z12.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
|
|
3487
|
+
offset: z12.number().int().min(0).optional().describe("Number of items to skip (default 0)")
|
|
3488
|
+
}
|
|
3489
|
+
}, async ({
|
|
3490
|
+
roadmapId,
|
|
3491
|
+
externalSystem,
|
|
3492
|
+
localEntityType,
|
|
3493
|
+
localEntityId,
|
|
3494
|
+
limit,
|
|
3495
|
+
offset
|
|
3496
|
+
}) => {
|
|
3497
|
+
const client2 = getApiClient();
|
|
3498
|
+
const response = await client2.searchExports({
|
|
3499
|
+
roadmapId,
|
|
3500
|
+
externalSystem,
|
|
3501
|
+
localEntityType,
|
|
3502
|
+
localEntityId,
|
|
3503
|
+
limit,
|
|
3504
|
+
offset
|
|
3505
|
+
});
|
|
3506
|
+
return {
|
|
3507
|
+
content: [
|
|
3508
|
+
{
|
|
3509
|
+
type: "text",
|
|
3510
|
+
text: JSON.stringify({
|
|
3511
|
+
exports: response.data,
|
|
3512
|
+
total: response.meta.total,
|
|
3513
|
+
hasMore: response.meta.has_more
|
|
3514
|
+
}, null, 2)
|
|
3515
|
+
}
|
|
3516
|
+
]
|
|
3517
|
+
};
|
|
3518
|
+
});
|
|
3519
|
+
}
|
|
3520
|
+
function registerGetExport(server) {
|
|
3521
|
+
server.registerTool("get_export", {
|
|
3522
|
+
description: "Get full details of a single export record by ID.",
|
|
3523
|
+
inputSchema: {
|
|
3524
|
+
id: z12.string().uuid().describe("The UUID of the export record")
|
|
3525
|
+
}
|
|
3526
|
+
}, async ({ id }) => {
|
|
3527
|
+
const client2 = getApiClient();
|
|
3528
|
+
const exportRecord = await client2.getExport(id);
|
|
3529
|
+
return {
|
|
3530
|
+
content: [
|
|
3531
|
+
{
|
|
3532
|
+
type: "text",
|
|
3533
|
+
text: JSON.stringify(exportRecord, null, 2)
|
|
3534
|
+
}
|
|
3535
|
+
]
|
|
3536
|
+
};
|
|
3537
|
+
});
|
|
3538
|
+
}
|
|
3539
|
+
function registerCreateExport(server) {
|
|
3540
|
+
server.registerTool("create_export", {
|
|
3541
|
+
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
|
+
inputSchema: {
|
|
3543
|
+
roadmapId: z12.string().uuid().describe("The UUID of the roadmap item"),
|
|
3544
|
+
localEntityType: z12.enum(["roadmap", "prd", "epic", "story", "design"]).describe("Type of local entity being exported"),
|
|
3545
|
+
localEntityId: z12.string().uuid().describe("The UUID of the local entity"),
|
|
3546
|
+
externalSystem: z12.enum(["linear", "notion", "jira", "github"]).describe("External system where the entity was exported"),
|
|
3547
|
+
externalObjectType: z12.string().min(1).describe('Type of object in the external system (e.g., "issue", "page", "project")'),
|
|
3548
|
+
externalId: z12.string().min(1).describe("ID of the object in the external system"),
|
|
3549
|
+
externalUrl: z12.string().url().optional().describe("URL to the object in the external system"),
|
|
3550
|
+
metadata: z12.record(z12.unknown()).optional().describe("Additional metadata about the export")
|
|
3551
|
+
}
|
|
3552
|
+
}, async ({
|
|
3553
|
+
roadmapId,
|
|
3554
|
+
localEntityType,
|
|
3555
|
+
localEntityId,
|
|
3556
|
+
externalSystem,
|
|
3557
|
+
externalObjectType,
|
|
3558
|
+
externalId,
|
|
3559
|
+
externalUrl,
|
|
3560
|
+
metadata
|
|
3561
|
+
}) => {
|
|
3562
|
+
const client2 = getApiClient();
|
|
3563
|
+
const exportRecord = await client2.createExport({
|
|
3564
|
+
roadmapId,
|
|
3565
|
+
localEntityType,
|
|
3566
|
+
localEntityId,
|
|
3567
|
+
externalSystem,
|
|
3568
|
+
externalObjectType,
|
|
3569
|
+
externalId,
|
|
3570
|
+
externalUrl,
|
|
3571
|
+
metadata
|
|
3572
|
+
});
|
|
3573
|
+
return {
|
|
3574
|
+
content: [
|
|
3575
|
+
{
|
|
3576
|
+
type: "text",
|
|
3577
|
+
text: JSON.stringify({ success: true, export: exportRecord }, null, 2)
|
|
3578
|
+
}
|
|
3579
|
+
]
|
|
3580
|
+
};
|
|
3581
|
+
});
|
|
3582
|
+
}
|
|
3583
|
+
function registerUpdateExport(server) {
|
|
3584
|
+
server.registerTool("update_export", {
|
|
3585
|
+
description: "Update an export record. Can update the external URL or metadata.",
|
|
3586
|
+
inputSchema: {
|
|
3587
|
+
id: z12.string().uuid().describe("The UUID of the export record to update"),
|
|
3588
|
+
externalUrl: z12.string().url().nullable().optional().describe("New URL to the object in the external system"),
|
|
3589
|
+
metadata: z12.record(z12.unknown()).optional().describe("New metadata to replace existing metadata")
|
|
3590
|
+
}
|
|
3591
|
+
}, async ({
|
|
3592
|
+
id,
|
|
3593
|
+
externalUrl,
|
|
3594
|
+
metadata
|
|
3595
|
+
}) => {
|
|
3596
|
+
const client2 = getApiClient();
|
|
3597
|
+
const exportRecord = await client2.updateExport(id, { externalUrl, metadata });
|
|
3598
|
+
return {
|
|
3599
|
+
content: [
|
|
3600
|
+
{
|
|
3601
|
+
type: "text",
|
|
3602
|
+
text: JSON.stringify({ success: true, export: exportRecord }, null, 2)
|
|
3603
|
+
}
|
|
3604
|
+
]
|
|
3605
|
+
};
|
|
3606
|
+
});
|
|
3607
|
+
}
|
|
3608
|
+
function registerDeleteExport(server) {
|
|
3609
|
+
server.registerTool("delete_export", {
|
|
3610
|
+
description: "Delete an export record. This is a soft delete.",
|
|
3611
|
+
inputSchema: {
|
|
3612
|
+
id: z12.string().uuid().describe("The UUID of the export record to delete")
|
|
3613
|
+
}
|
|
3614
|
+
}, async ({ id }) => {
|
|
3615
|
+
const client2 = getApiClient();
|
|
3616
|
+
await client2.deleteExport(id);
|
|
3617
|
+
return {
|
|
3618
|
+
content: [
|
|
3619
|
+
{
|
|
3620
|
+
type: "text",
|
|
3621
|
+
text: JSON.stringify({ success: true, deleted: id }, null, 2)
|
|
3622
|
+
}
|
|
3623
|
+
]
|
|
3624
|
+
};
|
|
3625
|
+
});
|
|
3626
|
+
}
|
|
3343
3627
|
|
|
3344
3628
|
// src/index.ts
|
|
3345
3629
|
async function main() {
|