@mastra/agent-builder 0.0.0-experimental-agent-builder-20250815195917 → 0.0.1-alpha.1
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/.turbo/turbo-build.log +12 -0
- package/CHANGELOG.md +7 -16
- package/README.md +4 -17
- package/dist/_tsup-dts-rollup.d.cts +2442 -618
- package/dist/_tsup-dts-rollup.d.ts +2442 -618
- package/dist/index.cjs +1134 -549
- package/dist/index.d.cts +3 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +1131 -553
- package/integration-tests/CHANGELOG.md +4 -15
- package/integration-tests/docker-compose.yml +3 -3
- package/integration-tests/package.json +3 -3
- package/integration-tests/src/agent-template-behavior.test.ts +1 -1
- package/integration-tests/src/fixtures/minimal-mastra-project/package.json +2 -2
- package/integration-tests/src/fixtures/minimal-mastra-project/src/mastra/tools/weather.ts +2 -1
- package/integration-tests/src/template-integration.test.ts +8 -8
- package/integration-tests/tsconfig.json +2 -6
- package/integration-tests/vitest.config.ts +1 -0
- package/package.json +7 -6
- package/src/agent/index.ts +187 -0
- package/src/agent-builder.test.ts +34 -12
- package/src/defaults.ts +292 -144
- package/src/index.ts +3 -187
- package/src/processors/tool-summary.ts +18 -9
- package/src/processors/write-file.ts +1 -1
- package/src/types.ts +188 -3
- package/src/utils.ts +289 -13
- package/src/workflows/index.ts +1 -1541
- package/src/workflows/template-builder.ts +1682 -0
|
@@ -2,10 +2,14 @@ import { Agent } from '@mastra/core/agent';
|
|
|
2
2
|
import type { CoreMessage } from '@mastra/core';
|
|
3
3
|
import { DefaultEngineType } from '@mastra/core';
|
|
4
4
|
import { exec as exec_2 } from 'child_process';
|
|
5
|
+
import { execFile as execFile_2 } from 'child_process';
|
|
5
6
|
import { GenerateTextResult } from '@mastra/core';
|
|
6
7
|
import type { MastraLanguageModel } from '@mastra/core/agent';
|
|
7
8
|
import type { MastraLanguageModel as MastraLanguageModel_2 } from '@mastra/core';
|
|
9
|
+
import type { MastraStorage } from '@mastra/core/storage';
|
|
10
|
+
import type { MastraVector } from '@mastra/core/vector';
|
|
8
11
|
import { MemoryProcessor } from '@mastra/core';
|
|
12
|
+
import type { SpawnOptions } from 'child_process';
|
|
9
13
|
import { Step } from '@mastra/core';
|
|
10
14
|
import { Tool } from '@mastra/core/tools';
|
|
11
15
|
import { ToolExecutionContext } from '@mastra/core';
|
|
@@ -25,10 +29,10 @@ import { ZodRecord } from 'zod';
|
|
|
25
29
|
import { ZodString } from 'zod';
|
|
26
30
|
import { ZodTypeAny } from 'zod';
|
|
27
31
|
|
|
28
|
-
|
|
32
|
+
declare class AgentBuilder extends Agent {
|
|
29
33
|
private builderConfig;
|
|
30
34
|
/**
|
|
31
|
-
*
|
|
35
|
+
* Constructor for AgentBuilder
|
|
32
36
|
*/
|
|
33
37
|
constructor(config: AgentBuilderConfig);
|
|
34
38
|
/**
|
|
@@ -56,7 +60,7 @@ export declare class AgentBuilder extends Agent {
|
|
|
56
60
|
memoryConfig: {
|
|
57
61
|
lastMessages: number;
|
|
58
62
|
};
|
|
59
|
-
tools: (projectPath
|
|
63
|
+
tools: (projectPath: string, mode?: "template" | "code-editor") => Promise<{
|
|
60
64
|
readFile: Tool<ZodObject< {
|
|
61
65
|
filePath: ZodString;
|
|
62
66
|
startLine: ZodOptional<ZodNumber>;
|
|
@@ -1020,14 +1024,14 @@ export declare class AgentBuilder extends Agent {
|
|
|
1020
1024
|
errors: ZodArray<ZodString, "many">;
|
|
1021
1025
|
backup: ZodOptional<ZodString>;
|
|
1022
1026
|
}, "strip", ZodTypeAny, {
|
|
1027
|
+
errors: string[];
|
|
1023
1028
|
filePath: string;
|
|
1024
1029
|
editsApplied: number;
|
|
1025
|
-
errors: string[];
|
|
1026
1030
|
backup?: string | undefined;
|
|
1027
1031
|
}, {
|
|
1032
|
+
errors: string[];
|
|
1028
1033
|
filePath: string;
|
|
1029
1034
|
editsApplied: number;
|
|
1030
|
-
errors: string[];
|
|
1031
1035
|
backup?: string | undefined;
|
|
1032
1036
|
}>, "many">;
|
|
1033
1037
|
message: ZodString;
|
|
@@ -1035,18 +1039,18 @@ export declare class AgentBuilder extends Agent {
|
|
|
1035
1039
|
message: string;
|
|
1036
1040
|
success: boolean;
|
|
1037
1041
|
results: {
|
|
1042
|
+
errors: string[];
|
|
1038
1043
|
filePath: string;
|
|
1039
1044
|
editsApplied: number;
|
|
1040
|
-
errors: string[];
|
|
1041
1045
|
backup?: string | undefined;
|
|
1042
1046
|
}[];
|
|
1043
1047
|
}, {
|
|
1044
1048
|
message: string;
|
|
1045
1049
|
success: boolean;
|
|
1046
1050
|
results: {
|
|
1051
|
+
errors: string[];
|
|
1047
1052
|
filePath: string;
|
|
1048
1053
|
editsApplied: number;
|
|
1049
|
-
errors: string[];
|
|
1050
1054
|
backup?: string | undefined;
|
|
1051
1055
|
}[];
|
|
1052
1056
|
}>, ToolExecutionContext<ZodObject< {
|
|
@@ -1163,14 +1167,14 @@ export declare class AgentBuilder extends Agent {
|
|
|
1163
1167
|
errors: ZodArray<ZodString, "many">;
|
|
1164
1168
|
backup: ZodOptional<ZodString>;
|
|
1165
1169
|
}, "strip", ZodTypeAny, {
|
|
1170
|
+
errors: string[];
|
|
1166
1171
|
filePath: string;
|
|
1167
1172
|
editsApplied: number;
|
|
1168
|
-
errors: string[];
|
|
1169
1173
|
backup?: string | undefined;
|
|
1170
1174
|
}, {
|
|
1175
|
+
errors: string[];
|
|
1171
1176
|
filePath: string;
|
|
1172
1177
|
editsApplied: number;
|
|
1173
|
-
errors: string[];
|
|
1174
1178
|
backup?: string | undefined;
|
|
1175
1179
|
}>, "many">;
|
|
1176
1180
|
message: ZodString;
|
|
@@ -1178,18 +1182,18 @@ export declare class AgentBuilder extends Agent {
|
|
|
1178
1182
|
message: string;
|
|
1179
1183
|
success: boolean;
|
|
1180
1184
|
results: {
|
|
1185
|
+
errors: string[];
|
|
1181
1186
|
filePath: string;
|
|
1182
1187
|
editsApplied: number;
|
|
1183
|
-
errors: string[];
|
|
1184
1188
|
backup?: string | undefined;
|
|
1185
1189
|
}[];
|
|
1186
1190
|
}, {
|
|
1187
1191
|
message: string;
|
|
1188
1192
|
success: boolean;
|
|
1189
1193
|
results: {
|
|
1194
|
+
errors: string[];
|
|
1190
1195
|
filePath: string;
|
|
1191
1196
|
editsApplied: number;
|
|
1192
|
-
errors: string[];
|
|
1193
1197
|
backup?: string | undefined;
|
|
1194
1198
|
}[];
|
|
1195
1199
|
}>;
|
|
@@ -1247,6 +1251,119 @@ export declare class AgentBuilder extends Agent {
|
|
|
1247
1251
|
createBackup?: boolean | undefined;
|
|
1248
1252
|
}>>) => Promise<any>;
|
|
1249
1253
|
};
|
|
1254
|
+
replaceLines: Tool<ZodObject< {
|
|
1255
|
+
filePath: ZodString;
|
|
1256
|
+
startLine: ZodNumber;
|
|
1257
|
+
endLine: ZodNumber;
|
|
1258
|
+
newContent: ZodString;
|
|
1259
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
1260
|
+
}, "strip", ZodTypeAny, {
|
|
1261
|
+
createBackup: boolean;
|
|
1262
|
+
filePath: string;
|
|
1263
|
+
startLine: number;
|
|
1264
|
+
endLine: number;
|
|
1265
|
+
newContent: string;
|
|
1266
|
+
}, {
|
|
1267
|
+
filePath: string;
|
|
1268
|
+
startLine: number;
|
|
1269
|
+
endLine: number;
|
|
1270
|
+
newContent: string;
|
|
1271
|
+
createBackup?: boolean | undefined;
|
|
1272
|
+
}>, ZodObject< {
|
|
1273
|
+
success: ZodBoolean;
|
|
1274
|
+
message: ZodString;
|
|
1275
|
+
linesReplaced: ZodOptional<ZodNumber>;
|
|
1276
|
+
backup: ZodOptional<ZodString>;
|
|
1277
|
+
error: ZodOptional<ZodString>;
|
|
1278
|
+
}, "strip", ZodTypeAny, {
|
|
1279
|
+
message: string;
|
|
1280
|
+
success: boolean;
|
|
1281
|
+
error?: string | undefined;
|
|
1282
|
+
linesReplaced?: number | undefined;
|
|
1283
|
+
backup?: string | undefined;
|
|
1284
|
+
}, {
|
|
1285
|
+
message: string;
|
|
1286
|
+
success: boolean;
|
|
1287
|
+
error?: string | undefined;
|
|
1288
|
+
linesReplaced?: number | undefined;
|
|
1289
|
+
backup?: string | undefined;
|
|
1290
|
+
}>, ToolExecutionContext<ZodObject< {
|
|
1291
|
+
filePath: ZodString;
|
|
1292
|
+
startLine: ZodNumber;
|
|
1293
|
+
endLine: ZodNumber;
|
|
1294
|
+
newContent: ZodString;
|
|
1295
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
1296
|
+
}, "strip", ZodTypeAny, {
|
|
1297
|
+
createBackup: boolean;
|
|
1298
|
+
filePath: string;
|
|
1299
|
+
startLine: number;
|
|
1300
|
+
endLine: number;
|
|
1301
|
+
newContent: string;
|
|
1302
|
+
}, {
|
|
1303
|
+
filePath: string;
|
|
1304
|
+
startLine: number;
|
|
1305
|
+
endLine: number;
|
|
1306
|
+
newContent: string;
|
|
1307
|
+
createBackup?: boolean | undefined;
|
|
1308
|
+
}>>> & {
|
|
1309
|
+
inputSchema: ZodObject< {
|
|
1310
|
+
filePath: ZodString;
|
|
1311
|
+
startLine: ZodNumber;
|
|
1312
|
+
endLine: ZodNumber;
|
|
1313
|
+
newContent: ZodString;
|
|
1314
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
1315
|
+
}, "strip", ZodTypeAny, {
|
|
1316
|
+
createBackup: boolean;
|
|
1317
|
+
filePath: string;
|
|
1318
|
+
startLine: number;
|
|
1319
|
+
endLine: number;
|
|
1320
|
+
newContent: string;
|
|
1321
|
+
}, {
|
|
1322
|
+
filePath: string;
|
|
1323
|
+
startLine: number;
|
|
1324
|
+
endLine: number;
|
|
1325
|
+
newContent: string;
|
|
1326
|
+
createBackup?: boolean | undefined;
|
|
1327
|
+
}>;
|
|
1328
|
+
outputSchema: ZodObject< {
|
|
1329
|
+
success: ZodBoolean;
|
|
1330
|
+
message: ZodString;
|
|
1331
|
+
linesReplaced: ZodOptional<ZodNumber>;
|
|
1332
|
+
backup: ZodOptional<ZodString>;
|
|
1333
|
+
error: ZodOptional<ZodString>;
|
|
1334
|
+
}, "strip", ZodTypeAny, {
|
|
1335
|
+
message: string;
|
|
1336
|
+
success: boolean;
|
|
1337
|
+
error?: string | undefined;
|
|
1338
|
+
linesReplaced?: number | undefined;
|
|
1339
|
+
backup?: string | undefined;
|
|
1340
|
+
}, {
|
|
1341
|
+
message: string;
|
|
1342
|
+
success: boolean;
|
|
1343
|
+
error?: string | undefined;
|
|
1344
|
+
linesReplaced?: number | undefined;
|
|
1345
|
+
backup?: string | undefined;
|
|
1346
|
+
}>;
|
|
1347
|
+
execute: (context: ToolExecutionContext<ZodObject< {
|
|
1348
|
+
filePath: ZodString;
|
|
1349
|
+
startLine: ZodNumber;
|
|
1350
|
+
endLine: ZodNumber;
|
|
1351
|
+
newContent: ZodString;
|
|
1352
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
1353
|
+
}, "strip", ZodTypeAny, {
|
|
1354
|
+
createBackup: boolean;
|
|
1355
|
+
filePath: string;
|
|
1356
|
+
startLine: number;
|
|
1357
|
+
endLine: number;
|
|
1358
|
+
newContent: string;
|
|
1359
|
+
}, {
|
|
1360
|
+
filePath: string;
|
|
1361
|
+
startLine: number;
|
|
1362
|
+
endLine: number;
|
|
1363
|
+
newContent: string;
|
|
1364
|
+
createBackup?: boolean | undefined;
|
|
1365
|
+
}>>) => Promise<any>;
|
|
1366
|
+
};
|
|
1250
1367
|
askClarification: Tool<ZodObject< {
|
|
1251
1368
|
question: ZodString;
|
|
1252
1369
|
options: ZodOptional<ZodArray<ZodObject< {
|
|
@@ -2296,13 +2413,13 @@ export declare class AgentBuilder extends Agent {
|
|
|
2296
2413
|
includeTests: ZodDefault<ZodBoolean>;
|
|
2297
2414
|
}, "strip", ZodTypeAny, {
|
|
2298
2415
|
path: string;
|
|
2299
|
-
action: "
|
|
2416
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2300
2417
|
depth: number;
|
|
2301
2418
|
includeTests: boolean;
|
|
2302
2419
|
language?: string | undefined;
|
|
2303
2420
|
}, {
|
|
2304
2421
|
path: string;
|
|
2305
|
-
action: "
|
|
2422
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2306
2423
|
language?: string | undefined;
|
|
2307
2424
|
depth?: number | undefined;
|
|
2308
2425
|
includeTests?: boolean | undefined;
|
|
@@ -2335,13 +2452,13 @@ export declare class AgentBuilder extends Agent {
|
|
|
2335
2452
|
target: ZodString;
|
|
2336
2453
|
}, "strip", ZodTypeAny, {
|
|
2337
2454
|
type: "import" | "require" | "include";
|
|
2338
|
-
name: string;
|
|
2339
2455
|
source: string;
|
|
2456
|
+
name: string;
|
|
2340
2457
|
target: string;
|
|
2341
2458
|
}, {
|
|
2342
2459
|
type: "import" | "require" | "include";
|
|
2343
|
-
name: string;
|
|
2344
2460
|
source: string;
|
|
2461
|
+
name: string;
|
|
2345
2462
|
target: string;
|
|
2346
2463
|
}>, "many">>;
|
|
2347
2464
|
patterns: ZodOptional<ZodArray<ZodObject< {
|
|
@@ -2374,6 +2491,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2374
2491
|
complexity: string;
|
|
2375
2492
|
}>>;
|
|
2376
2493
|
}, "strip", ZodTypeAny, {
|
|
2494
|
+
dependencies?: {
|
|
2495
|
+
type: "import" | "require" | "include";
|
|
2496
|
+
source: string;
|
|
2497
|
+
name: string;
|
|
2498
|
+
target: string;
|
|
2499
|
+
}[] | undefined;
|
|
2377
2500
|
definitions?: {
|
|
2378
2501
|
type: string;
|
|
2379
2502
|
file: string;
|
|
@@ -2381,12 +2504,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2381
2504
|
scope?: string | undefined;
|
|
2382
2505
|
line?: number | undefined;
|
|
2383
2506
|
}[] | undefined;
|
|
2384
|
-
dependencies?: {
|
|
2385
|
-
type: "import" | "require" | "include";
|
|
2386
|
-
name: string;
|
|
2387
|
-
source: string;
|
|
2388
|
-
target: string;
|
|
2389
|
-
}[] | undefined;
|
|
2390
2507
|
patterns?: {
|
|
2391
2508
|
description: string;
|
|
2392
2509
|
files: string[];
|
|
@@ -2399,6 +2516,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2399
2516
|
complexity: string;
|
|
2400
2517
|
} | undefined;
|
|
2401
2518
|
}, {
|
|
2519
|
+
dependencies?: {
|
|
2520
|
+
type: "import" | "require" | "include";
|
|
2521
|
+
source: string;
|
|
2522
|
+
name: string;
|
|
2523
|
+
target: string;
|
|
2524
|
+
}[] | undefined;
|
|
2402
2525
|
definitions?: {
|
|
2403
2526
|
type: string;
|
|
2404
2527
|
file: string;
|
|
@@ -2406,12 +2529,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2406
2529
|
scope?: string | undefined;
|
|
2407
2530
|
line?: number | undefined;
|
|
2408
2531
|
}[] | undefined;
|
|
2409
|
-
dependencies?: {
|
|
2410
|
-
type: "import" | "require" | "include";
|
|
2411
|
-
name: string;
|
|
2412
|
-
source: string;
|
|
2413
|
-
target: string;
|
|
2414
|
-
}[] | undefined;
|
|
2415
2532
|
patterns?: {
|
|
2416
2533
|
description: string;
|
|
2417
2534
|
files: string[];
|
|
@@ -2429,6 +2546,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2429
2546
|
message: string;
|
|
2430
2547
|
success: boolean;
|
|
2431
2548
|
analysis: {
|
|
2549
|
+
dependencies?: {
|
|
2550
|
+
type: "import" | "require" | "include";
|
|
2551
|
+
source: string;
|
|
2552
|
+
name: string;
|
|
2553
|
+
target: string;
|
|
2554
|
+
}[] | undefined;
|
|
2432
2555
|
definitions?: {
|
|
2433
2556
|
type: string;
|
|
2434
2557
|
file: string;
|
|
@@ -2436,12 +2559,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2436
2559
|
scope?: string | undefined;
|
|
2437
2560
|
line?: number | undefined;
|
|
2438
2561
|
}[] | undefined;
|
|
2439
|
-
dependencies?: {
|
|
2440
|
-
type: "import" | "require" | "include";
|
|
2441
|
-
name: string;
|
|
2442
|
-
source: string;
|
|
2443
|
-
target: string;
|
|
2444
|
-
}[] | undefined;
|
|
2445
2562
|
patterns?: {
|
|
2446
2563
|
description: string;
|
|
2447
2564
|
files: string[];
|
|
@@ -2458,6 +2575,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2458
2575
|
message: string;
|
|
2459
2576
|
success: boolean;
|
|
2460
2577
|
analysis: {
|
|
2578
|
+
dependencies?: {
|
|
2579
|
+
type: "import" | "require" | "include";
|
|
2580
|
+
source: string;
|
|
2581
|
+
name: string;
|
|
2582
|
+
target: string;
|
|
2583
|
+
}[] | undefined;
|
|
2461
2584
|
definitions?: {
|
|
2462
2585
|
type: string;
|
|
2463
2586
|
file: string;
|
|
@@ -2465,12 +2588,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2465
2588
|
scope?: string | undefined;
|
|
2466
2589
|
line?: number | undefined;
|
|
2467
2590
|
}[] | undefined;
|
|
2468
|
-
dependencies?: {
|
|
2469
|
-
type: "import" | "require" | "include";
|
|
2470
|
-
name: string;
|
|
2471
|
-
source: string;
|
|
2472
|
-
target: string;
|
|
2473
|
-
}[] | undefined;
|
|
2474
2591
|
patterns?: {
|
|
2475
2592
|
description: string;
|
|
2476
2593
|
files: string[];
|
|
@@ -2491,13 +2608,13 @@ export declare class AgentBuilder extends Agent {
|
|
|
2491
2608
|
includeTests: ZodDefault<ZodBoolean>;
|
|
2492
2609
|
}, "strip", ZodTypeAny, {
|
|
2493
2610
|
path: string;
|
|
2494
|
-
action: "
|
|
2611
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2495
2612
|
depth: number;
|
|
2496
2613
|
includeTests: boolean;
|
|
2497
2614
|
language?: string | undefined;
|
|
2498
2615
|
}, {
|
|
2499
2616
|
path: string;
|
|
2500
|
-
action: "
|
|
2617
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2501
2618
|
language?: string | undefined;
|
|
2502
2619
|
depth?: number | undefined;
|
|
2503
2620
|
includeTests?: boolean | undefined;
|
|
@@ -2510,13 +2627,13 @@ export declare class AgentBuilder extends Agent {
|
|
|
2510
2627
|
includeTests: ZodDefault<ZodBoolean>;
|
|
2511
2628
|
}, "strip", ZodTypeAny, {
|
|
2512
2629
|
path: string;
|
|
2513
|
-
action: "
|
|
2630
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2514
2631
|
depth: number;
|
|
2515
2632
|
includeTests: boolean;
|
|
2516
2633
|
language?: string | undefined;
|
|
2517
2634
|
}, {
|
|
2518
2635
|
path: string;
|
|
2519
|
-
action: "
|
|
2636
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2520
2637
|
language?: string | undefined;
|
|
2521
2638
|
depth?: number | undefined;
|
|
2522
2639
|
includeTests?: boolean | undefined;
|
|
@@ -2550,13 +2667,13 @@ export declare class AgentBuilder extends Agent {
|
|
|
2550
2667
|
target: ZodString;
|
|
2551
2668
|
}, "strip", ZodTypeAny, {
|
|
2552
2669
|
type: "import" | "require" | "include";
|
|
2553
|
-
name: string;
|
|
2554
2670
|
source: string;
|
|
2671
|
+
name: string;
|
|
2555
2672
|
target: string;
|
|
2556
2673
|
}, {
|
|
2557
2674
|
type: "import" | "require" | "include";
|
|
2558
|
-
name: string;
|
|
2559
2675
|
source: string;
|
|
2676
|
+
name: string;
|
|
2560
2677
|
target: string;
|
|
2561
2678
|
}>, "many">>;
|
|
2562
2679
|
patterns: ZodOptional<ZodArray<ZodObject< {
|
|
@@ -2589,6 +2706,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2589
2706
|
complexity: string;
|
|
2590
2707
|
}>>;
|
|
2591
2708
|
}, "strip", ZodTypeAny, {
|
|
2709
|
+
dependencies?: {
|
|
2710
|
+
type: "import" | "require" | "include";
|
|
2711
|
+
source: string;
|
|
2712
|
+
name: string;
|
|
2713
|
+
target: string;
|
|
2714
|
+
}[] | undefined;
|
|
2592
2715
|
definitions?: {
|
|
2593
2716
|
type: string;
|
|
2594
2717
|
file: string;
|
|
@@ -2596,12 +2719,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2596
2719
|
scope?: string | undefined;
|
|
2597
2720
|
line?: number | undefined;
|
|
2598
2721
|
}[] | undefined;
|
|
2599
|
-
dependencies?: {
|
|
2600
|
-
type: "import" | "require" | "include";
|
|
2601
|
-
name: string;
|
|
2602
|
-
source: string;
|
|
2603
|
-
target: string;
|
|
2604
|
-
}[] | undefined;
|
|
2605
2722
|
patterns?: {
|
|
2606
2723
|
description: string;
|
|
2607
2724
|
files: string[];
|
|
@@ -2614,6 +2731,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2614
2731
|
complexity: string;
|
|
2615
2732
|
} | undefined;
|
|
2616
2733
|
}, {
|
|
2734
|
+
dependencies?: {
|
|
2735
|
+
type: "import" | "require" | "include";
|
|
2736
|
+
source: string;
|
|
2737
|
+
name: string;
|
|
2738
|
+
target: string;
|
|
2739
|
+
}[] | undefined;
|
|
2617
2740
|
definitions?: {
|
|
2618
2741
|
type: string;
|
|
2619
2742
|
file: string;
|
|
@@ -2621,12 +2744,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2621
2744
|
scope?: string | undefined;
|
|
2622
2745
|
line?: number | undefined;
|
|
2623
2746
|
}[] | undefined;
|
|
2624
|
-
dependencies?: {
|
|
2625
|
-
type: "import" | "require" | "include";
|
|
2626
|
-
name: string;
|
|
2627
|
-
source: string;
|
|
2628
|
-
target: string;
|
|
2629
|
-
}[] | undefined;
|
|
2630
2747
|
patterns?: {
|
|
2631
2748
|
description: string;
|
|
2632
2749
|
files: string[];
|
|
@@ -2644,6 +2761,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2644
2761
|
message: string;
|
|
2645
2762
|
success: boolean;
|
|
2646
2763
|
analysis: {
|
|
2764
|
+
dependencies?: {
|
|
2765
|
+
type: "import" | "require" | "include";
|
|
2766
|
+
source: string;
|
|
2767
|
+
name: string;
|
|
2768
|
+
target: string;
|
|
2769
|
+
}[] | undefined;
|
|
2647
2770
|
definitions?: {
|
|
2648
2771
|
type: string;
|
|
2649
2772
|
file: string;
|
|
@@ -2651,12 +2774,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2651
2774
|
scope?: string | undefined;
|
|
2652
2775
|
line?: number | undefined;
|
|
2653
2776
|
}[] | undefined;
|
|
2654
|
-
dependencies?: {
|
|
2655
|
-
type: "import" | "require" | "include";
|
|
2656
|
-
name: string;
|
|
2657
|
-
source: string;
|
|
2658
|
-
target: string;
|
|
2659
|
-
}[] | undefined;
|
|
2660
2777
|
patterns?: {
|
|
2661
2778
|
description: string;
|
|
2662
2779
|
files: string[];
|
|
@@ -2673,6 +2790,12 @@ export declare class AgentBuilder extends Agent {
|
|
|
2673
2790
|
message: string;
|
|
2674
2791
|
success: boolean;
|
|
2675
2792
|
analysis: {
|
|
2793
|
+
dependencies?: {
|
|
2794
|
+
type: "import" | "require" | "include";
|
|
2795
|
+
source: string;
|
|
2796
|
+
name: string;
|
|
2797
|
+
target: string;
|
|
2798
|
+
}[] | undefined;
|
|
2676
2799
|
definitions?: {
|
|
2677
2800
|
type: string;
|
|
2678
2801
|
file: string;
|
|
@@ -2680,12 +2803,6 @@ export declare class AgentBuilder extends Agent {
|
|
|
2680
2803
|
scope?: string | undefined;
|
|
2681
2804
|
line?: number | undefined;
|
|
2682
2805
|
}[] | undefined;
|
|
2683
|
-
dependencies?: {
|
|
2684
|
-
type: "import" | "require" | "include";
|
|
2685
|
-
name: string;
|
|
2686
|
-
source: string;
|
|
2687
|
-
target: string;
|
|
2688
|
-
}[] | undefined;
|
|
2689
2806
|
patterns?: {
|
|
2690
2807
|
description: string;
|
|
2691
2808
|
files: string[];
|
|
@@ -2707,13 +2824,13 @@ export declare class AgentBuilder extends Agent {
|
|
|
2707
2824
|
includeTests: ZodDefault<ZodBoolean>;
|
|
2708
2825
|
}, "strip", ZodTypeAny, {
|
|
2709
2826
|
path: string;
|
|
2710
|
-
action: "
|
|
2827
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2711
2828
|
depth: number;
|
|
2712
2829
|
includeTests: boolean;
|
|
2713
2830
|
language?: string | undefined;
|
|
2714
2831
|
}, {
|
|
2715
2832
|
path: string;
|
|
2716
|
-
action: "
|
|
2833
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
2717
2834
|
language?: string | undefined;
|
|
2718
2835
|
depth?: number | undefined;
|
|
2719
2836
|
includeTests?: boolean | undefined;
|
|
@@ -4336,14 +4453,14 @@ export declare class AgentBuilder extends Agent {
|
|
|
4336
4453
|
errors: ZodArray<ZodString, "many">;
|
|
4337
4454
|
backup: ZodOptional<ZodString>;
|
|
4338
4455
|
}, "strip", ZodTypeAny, {
|
|
4456
|
+
errors: string[];
|
|
4339
4457
|
filePath: string;
|
|
4340
4458
|
editsApplied: number;
|
|
4341
|
-
errors: string[];
|
|
4342
4459
|
backup?: string | undefined;
|
|
4343
4460
|
}, {
|
|
4461
|
+
errors: string[];
|
|
4344
4462
|
filePath: string;
|
|
4345
4463
|
editsApplied: number;
|
|
4346
|
-
errors: string[];
|
|
4347
4464
|
backup?: string | undefined;
|
|
4348
4465
|
}>, "many">;
|
|
4349
4466
|
message: ZodString;
|
|
@@ -4351,18 +4468,18 @@ export declare class AgentBuilder extends Agent {
|
|
|
4351
4468
|
message: string;
|
|
4352
4469
|
success: boolean;
|
|
4353
4470
|
results: {
|
|
4471
|
+
errors: string[];
|
|
4354
4472
|
filePath: string;
|
|
4355
4473
|
editsApplied: number;
|
|
4356
|
-
errors: string[];
|
|
4357
4474
|
backup?: string | undefined;
|
|
4358
4475
|
}[];
|
|
4359
4476
|
}, {
|
|
4360
4477
|
message: string;
|
|
4361
4478
|
success: boolean;
|
|
4362
4479
|
results: {
|
|
4480
|
+
errors: string[];
|
|
4363
4481
|
filePath: string;
|
|
4364
4482
|
editsApplied: number;
|
|
4365
|
-
errors: string[];
|
|
4366
4483
|
backup?: string | undefined;
|
|
4367
4484
|
}[];
|
|
4368
4485
|
}>, ToolExecutionContext<ZodObject< {
|
|
@@ -4479,14 +4596,14 @@ export declare class AgentBuilder extends Agent {
|
|
|
4479
4596
|
errors: ZodArray<ZodString, "many">;
|
|
4480
4597
|
backup: ZodOptional<ZodString>;
|
|
4481
4598
|
}, "strip", ZodTypeAny, {
|
|
4599
|
+
errors: string[];
|
|
4482
4600
|
filePath: string;
|
|
4483
4601
|
editsApplied: number;
|
|
4484
|
-
errors: string[];
|
|
4485
4602
|
backup?: string | undefined;
|
|
4486
4603
|
}, {
|
|
4604
|
+
errors: string[];
|
|
4487
4605
|
filePath: string;
|
|
4488
4606
|
editsApplied: number;
|
|
4489
|
-
errors: string[];
|
|
4490
4607
|
backup?: string | undefined;
|
|
4491
4608
|
}>, "many">;
|
|
4492
4609
|
message: ZodString;
|
|
@@ -4494,18 +4611,18 @@ export declare class AgentBuilder extends Agent {
|
|
|
4494
4611
|
message: string;
|
|
4495
4612
|
success: boolean;
|
|
4496
4613
|
results: {
|
|
4614
|
+
errors: string[];
|
|
4497
4615
|
filePath: string;
|
|
4498
4616
|
editsApplied: number;
|
|
4499
|
-
errors: string[];
|
|
4500
4617
|
backup?: string | undefined;
|
|
4501
4618
|
}[];
|
|
4502
4619
|
}, {
|
|
4503
4620
|
message: string;
|
|
4504
4621
|
success: boolean;
|
|
4505
4622
|
results: {
|
|
4623
|
+
errors: string[];
|
|
4506
4624
|
filePath: string;
|
|
4507
4625
|
editsApplied: number;
|
|
4508
|
-
errors: string[];
|
|
4509
4626
|
backup?: string | undefined;
|
|
4510
4627
|
}[];
|
|
4511
4628
|
}>;
|
|
@@ -4563,50 +4680,163 @@ export declare class AgentBuilder extends Agent {
|
|
|
4563
4680
|
createBackup?: boolean | undefined;
|
|
4564
4681
|
}>>) => Promise<any>;
|
|
4565
4682
|
};
|
|
4566
|
-
|
|
4567
|
-
|
|
4568
|
-
|
|
4569
|
-
|
|
4570
|
-
|
|
4571
|
-
|
|
4572
|
-
}, "strip", ZodTypeAny, {
|
|
4573
|
-
id: string;
|
|
4574
|
-
description: string;
|
|
4575
|
-
implications?: string | undefined;
|
|
4576
|
-
}, {
|
|
4577
|
-
id: string;
|
|
4578
|
-
description: string;
|
|
4579
|
-
implications?: string | undefined;
|
|
4580
|
-
}>, "many">>;
|
|
4581
|
-
context: ZodOptional<ZodString>;
|
|
4582
|
-
urgency: ZodDefault<ZodEnum<["low", "medium", "high"]>>;
|
|
4683
|
+
replaceLines: Tool<ZodObject< {
|
|
4684
|
+
filePath: ZodString;
|
|
4685
|
+
startLine: ZodNumber;
|
|
4686
|
+
endLine: ZodNumber;
|
|
4687
|
+
newContent: ZodString;
|
|
4688
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
4583
4689
|
}, "strip", ZodTypeAny, {
|
|
4584
|
-
|
|
4585
|
-
|
|
4586
|
-
|
|
4587
|
-
|
|
4588
|
-
|
|
4589
|
-
implications?: string | undefined;
|
|
4590
|
-
}[] | undefined;
|
|
4591
|
-
context?: string | undefined;
|
|
4690
|
+
createBackup: boolean;
|
|
4691
|
+
filePath: string;
|
|
4692
|
+
startLine: number;
|
|
4693
|
+
endLine: number;
|
|
4694
|
+
newContent: string;
|
|
4592
4695
|
}, {
|
|
4593
|
-
|
|
4594
|
-
|
|
4595
|
-
|
|
4596
|
-
|
|
4597
|
-
|
|
4598
|
-
}[] | undefined;
|
|
4599
|
-
context?: string | undefined;
|
|
4600
|
-
urgency?: "high" | "medium" | "low" | undefined;
|
|
4696
|
+
filePath: string;
|
|
4697
|
+
startLine: number;
|
|
4698
|
+
endLine: number;
|
|
4699
|
+
newContent: string;
|
|
4700
|
+
createBackup?: boolean | undefined;
|
|
4601
4701
|
}>, ZodObject< {
|
|
4602
|
-
|
|
4603
|
-
|
|
4604
|
-
|
|
4605
|
-
|
|
4606
|
-
|
|
4702
|
+
success: ZodBoolean;
|
|
4703
|
+
message: ZodString;
|
|
4704
|
+
linesReplaced: ZodOptional<ZodNumber>;
|
|
4705
|
+
backup: ZodOptional<ZodString>;
|
|
4706
|
+
error: ZodOptional<ZodString>;
|
|
4607
4707
|
}, "strip", ZodTypeAny, {
|
|
4608
|
-
|
|
4609
|
-
|
|
4708
|
+
message: string;
|
|
4709
|
+
success: boolean;
|
|
4710
|
+
error?: string | undefined;
|
|
4711
|
+
linesReplaced?: number | undefined;
|
|
4712
|
+
backup?: string | undefined;
|
|
4713
|
+
}, {
|
|
4714
|
+
message: string;
|
|
4715
|
+
success: boolean;
|
|
4716
|
+
error?: string | undefined;
|
|
4717
|
+
linesReplaced?: number | undefined;
|
|
4718
|
+
backup?: string | undefined;
|
|
4719
|
+
}>, ToolExecutionContext<ZodObject< {
|
|
4720
|
+
filePath: ZodString;
|
|
4721
|
+
startLine: ZodNumber;
|
|
4722
|
+
endLine: ZodNumber;
|
|
4723
|
+
newContent: ZodString;
|
|
4724
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
4725
|
+
}, "strip", ZodTypeAny, {
|
|
4726
|
+
createBackup: boolean;
|
|
4727
|
+
filePath: string;
|
|
4728
|
+
startLine: number;
|
|
4729
|
+
endLine: number;
|
|
4730
|
+
newContent: string;
|
|
4731
|
+
}, {
|
|
4732
|
+
filePath: string;
|
|
4733
|
+
startLine: number;
|
|
4734
|
+
endLine: number;
|
|
4735
|
+
newContent: string;
|
|
4736
|
+
createBackup?: boolean | undefined;
|
|
4737
|
+
}>>> & {
|
|
4738
|
+
inputSchema: ZodObject< {
|
|
4739
|
+
filePath: ZodString;
|
|
4740
|
+
startLine: ZodNumber;
|
|
4741
|
+
endLine: ZodNumber;
|
|
4742
|
+
newContent: ZodString;
|
|
4743
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
4744
|
+
}, "strip", ZodTypeAny, {
|
|
4745
|
+
createBackup: boolean;
|
|
4746
|
+
filePath: string;
|
|
4747
|
+
startLine: number;
|
|
4748
|
+
endLine: number;
|
|
4749
|
+
newContent: string;
|
|
4750
|
+
}, {
|
|
4751
|
+
filePath: string;
|
|
4752
|
+
startLine: number;
|
|
4753
|
+
endLine: number;
|
|
4754
|
+
newContent: string;
|
|
4755
|
+
createBackup?: boolean | undefined;
|
|
4756
|
+
}>;
|
|
4757
|
+
outputSchema: ZodObject< {
|
|
4758
|
+
success: ZodBoolean;
|
|
4759
|
+
message: ZodString;
|
|
4760
|
+
linesReplaced: ZodOptional<ZodNumber>;
|
|
4761
|
+
backup: ZodOptional<ZodString>;
|
|
4762
|
+
error: ZodOptional<ZodString>;
|
|
4763
|
+
}, "strip", ZodTypeAny, {
|
|
4764
|
+
message: string;
|
|
4765
|
+
success: boolean;
|
|
4766
|
+
error?: string | undefined;
|
|
4767
|
+
linesReplaced?: number | undefined;
|
|
4768
|
+
backup?: string | undefined;
|
|
4769
|
+
}, {
|
|
4770
|
+
message: string;
|
|
4771
|
+
success: boolean;
|
|
4772
|
+
error?: string | undefined;
|
|
4773
|
+
linesReplaced?: number | undefined;
|
|
4774
|
+
backup?: string | undefined;
|
|
4775
|
+
}>;
|
|
4776
|
+
execute: (context: ToolExecutionContext<ZodObject< {
|
|
4777
|
+
filePath: ZodString;
|
|
4778
|
+
startLine: ZodNumber;
|
|
4779
|
+
endLine: ZodNumber;
|
|
4780
|
+
newContent: ZodString;
|
|
4781
|
+
createBackup: ZodDefault<ZodBoolean>;
|
|
4782
|
+
}, "strip", ZodTypeAny, {
|
|
4783
|
+
createBackup: boolean;
|
|
4784
|
+
filePath: string;
|
|
4785
|
+
startLine: number;
|
|
4786
|
+
endLine: number;
|
|
4787
|
+
newContent: string;
|
|
4788
|
+
}, {
|
|
4789
|
+
filePath: string;
|
|
4790
|
+
startLine: number;
|
|
4791
|
+
endLine: number;
|
|
4792
|
+
newContent: string;
|
|
4793
|
+
createBackup?: boolean | undefined;
|
|
4794
|
+
}>>) => Promise<any>;
|
|
4795
|
+
};
|
|
4796
|
+
askClarification: Tool<ZodObject< {
|
|
4797
|
+
question: ZodString;
|
|
4798
|
+
options: ZodOptional<ZodArray<ZodObject< {
|
|
4799
|
+
id: ZodString;
|
|
4800
|
+
description: ZodString;
|
|
4801
|
+
implications: ZodOptional<ZodString>;
|
|
4802
|
+
}, "strip", ZodTypeAny, {
|
|
4803
|
+
id: string;
|
|
4804
|
+
description: string;
|
|
4805
|
+
implications?: string | undefined;
|
|
4806
|
+
}, {
|
|
4807
|
+
id: string;
|
|
4808
|
+
description: string;
|
|
4809
|
+
implications?: string | undefined;
|
|
4810
|
+
}>, "many">>;
|
|
4811
|
+
context: ZodOptional<ZodString>;
|
|
4812
|
+
urgency: ZodDefault<ZodEnum<["low", "medium", "high"]>>;
|
|
4813
|
+
}, "strip", ZodTypeAny, {
|
|
4814
|
+
question: string;
|
|
4815
|
+
urgency: "high" | "medium" | "low";
|
|
4816
|
+
options?: {
|
|
4817
|
+
id: string;
|
|
4818
|
+
description: string;
|
|
4819
|
+
implications?: string | undefined;
|
|
4820
|
+
}[] | undefined;
|
|
4821
|
+
context?: string | undefined;
|
|
4822
|
+
}, {
|
|
4823
|
+
question: string;
|
|
4824
|
+
options?: {
|
|
4825
|
+
id: string;
|
|
4826
|
+
description: string;
|
|
4827
|
+
implications?: string | undefined;
|
|
4828
|
+
}[] | undefined;
|
|
4829
|
+
context?: string | undefined;
|
|
4830
|
+
urgency?: "high" | "medium" | "low" | undefined;
|
|
4831
|
+
}>, ZodObject< {
|
|
4832
|
+
questionId: ZodString;
|
|
4833
|
+
question: ZodString;
|
|
4834
|
+
options: ZodOptional<ZodArray<ZodObject< {
|
|
4835
|
+
id: ZodString;
|
|
4836
|
+
description: ZodString;
|
|
4837
|
+
}, "strip", ZodTypeAny, {
|
|
4838
|
+
id: string;
|
|
4839
|
+
description: string;
|
|
4610
4840
|
}, {
|
|
4611
4841
|
id: string;
|
|
4612
4842
|
description: string;
|
|
@@ -5399,6 +5629,8 @@ export declare class AgentBuilder extends Agent {
|
|
|
5399
5629
|
}>;
|
|
5400
5630
|
};
|
|
5401
5631
|
}
|
|
5632
|
+
export { AgentBuilder }
|
|
5633
|
+
export { AgentBuilder as AgentBuilder_alias_1 }
|
|
5402
5634
|
|
|
5403
5635
|
/**
|
|
5404
5636
|
* Configuration options for the AgentBuilder
|
|
@@ -5407,9 +5639,9 @@ export declare interface AgentBuilderConfig {
|
|
|
5407
5639
|
/** The language model to use for agent generation */
|
|
5408
5640
|
model: MastraLanguageModel;
|
|
5409
5641
|
/** Storage provider for memory (optional) */
|
|
5410
|
-
storage?:
|
|
5642
|
+
storage?: MastraStorage;
|
|
5411
5643
|
/** Vector provider for memory (optional) */
|
|
5412
|
-
vectorProvider?:
|
|
5644
|
+
vectorProvider?: MastraVector;
|
|
5413
5645
|
/** Additional tools to include beyond the default set */
|
|
5414
5646
|
tools?: ToolsInput;
|
|
5415
5647
|
/** Custom instructions to append to the default system prompt */
|
|
@@ -5427,7 +5659,7 @@ export declare interface AgentBuilderConfig {
|
|
|
5427
5659
|
mode?: 'template' | 'code-editor';
|
|
5428
5660
|
}
|
|
5429
5661
|
|
|
5430
|
-
|
|
5662
|
+
declare class AgentBuilderDefaults {
|
|
5431
5663
|
static DEFAULT_INSTRUCTIONS: (projectPath?: string) => string;
|
|
5432
5664
|
static DEFAULT_MEMORY_CONFIG: {
|
|
5433
5665
|
lastMessages: number;
|
|
@@ -5439,7 +5671,7 @@ export declare class AgentBuilderDefaults {
|
|
|
5439
5671
|
'mcp-server': string;
|
|
5440
5672
|
network: string;
|
|
5441
5673
|
};
|
|
5442
|
-
static DEFAULT_TOOLS: (projectPath
|
|
5674
|
+
static DEFAULT_TOOLS: (projectPath: string, mode?: "template" | "code-editor") => Promise<{
|
|
5443
5675
|
readFile: Tool<z.ZodObject<{
|
|
5444
5676
|
filePath: z.ZodString;
|
|
5445
5677
|
startLine: z.ZodOptional<z.ZodNumber>;
|
|
@@ -6403,14 +6635,14 @@ export declare class AgentBuilderDefaults {
|
|
|
6403
6635
|
errors: z.ZodArray<z.ZodString, "many">;
|
|
6404
6636
|
backup: z.ZodOptional<z.ZodString>;
|
|
6405
6637
|
}, "strip", z.ZodTypeAny, {
|
|
6638
|
+
errors: string[];
|
|
6406
6639
|
filePath: string;
|
|
6407
6640
|
editsApplied: number;
|
|
6408
|
-
errors: string[];
|
|
6409
6641
|
backup?: string | undefined;
|
|
6410
6642
|
}, {
|
|
6643
|
+
errors: string[];
|
|
6411
6644
|
filePath: string;
|
|
6412
6645
|
editsApplied: number;
|
|
6413
|
-
errors: string[];
|
|
6414
6646
|
backup?: string | undefined;
|
|
6415
6647
|
}>, "many">;
|
|
6416
6648
|
message: z.ZodString;
|
|
@@ -6418,18 +6650,18 @@ export declare class AgentBuilderDefaults {
|
|
|
6418
6650
|
message: string;
|
|
6419
6651
|
success: boolean;
|
|
6420
6652
|
results: {
|
|
6653
|
+
errors: string[];
|
|
6421
6654
|
filePath: string;
|
|
6422
6655
|
editsApplied: number;
|
|
6423
|
-
errors: string[];
|
|
6424
6656
|
backup?: string | undefined;
|
|
6425
6657
|
}[];
|
|
6426
6658
|
}, {
|
|
6427
6659
|
message: string;
|
|
6428
6660
|
success: boolean;
|
|
6429
6661
|
results: {
|
|
6662
|
+
errors: string[];
|
|
6430
6663
|
filePath: string;
|
|
6431
6664
|
editsApplied: number;
|
|
6432
|
-
errors: string[];
|
|
6433
6665
|
backup?: string | undefined;
|
|
6434
6666
|
}[];
|
|
6435
6667
|
}>, ToolExecutionContext<z.ZodObject<{
|
|
@@ -6546,14 +6778,14 @@ export declare class AgentBuilderDefaults {
|
|
|
6546
6778
|
errors: z.ZodArray<z.ZodString, "many">;
|
|
6547
6779
|
backup: z.ZodOptional<z.ZodString>;
|
|
6548
6780
|
}, "strip", z.ZodTypeAny, {
|
|
6781
|
+
errors: string[];
|
|
6549
6782
|
filePath: string;
|
|
6550
6783
|
editsApplied: number;
|
|
6551
|
-
errors: string[];
|
|
6552
6784
|
backup?: string | undefined;
|
|
6553
6785
|
}, {
|
|
6786
|
+
errors: string[];
|
|
6554
6787
|
filePath: string;
|
|
6555
6788
|
editsApplied: number;
|
|
6556
|
-
errors: string[];
|
|
6557
6789
|
backup?: string | undefined;
|
|
6558
6790
|
}>, "many">;
|
|
6559
6791
|
message: z.ZodString;
|
|
@@ -6561,18 +6793,18 @@ export declare class AgentBuilderDefaults {
|
|
|
6561
6793
|
message: string;
|
|
6562
6794
|
success: boolean;
|
|
6563
6795
|
results: {
|
|
6796
|
+
errors: string[];
|
|
6564
6797
|
filePath: string;
|
|
6565
6798
|
editsApplied: number;
|
|
6566
|
-
errors: string[];
|
|
6567
6799
|
backup?: string | undefined;
|
|
6568
6800
|
}[];
|
|
6569
6801
|
}, {
|
|
6570
6802
|
message: string;
|
|
6571
6803
|
success: boolean;
|
|
6572
6804
|
results: {
|
|
6805
|
+
errors: string[];
|
|
6573
6806
|
filePath: string;
|
|
6574
6807
|
editsApplied: number;
|
|
6575
|
-
errors: string[];
|
|
6576
6808
|
backup?: string | undefined;
|
|
6577
6809
|
}[];
|
|
6578
6810
|
}>;
|
|
@@ -6630,6 +6862,119 @@ export declare class AgentBuilderDefaults {
|
|
|
6630
6862
|
createBackup?: boolean | undefined;
|
|
6631
6863
|
}>>) => Promise<any>;
|
|
6632
6864
|
};
|
|
6865
|
+
replaceLines: Tool<z.ZodObject<{
|
|
6866
|
+
filePath: z.ZodString;
|
|
6867
|
+
startLine: z.ZodNumber;
|
|
6868
|
+
endLine: z.ZodNumber;
|
|
6869
|
+
newContent: z.ZodString;
|
|
6870
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
6871
|
+
}, "strip", z.ZodTypeAny, {
|
|
6872
|
+
createBackup: boolean;
|
|
6873
|
+
filePath: string;
|
|
6874
|
+
startLine: number;
|
|
6875
|
+
endLine: number;
|
|
6876
|
+
newContent: string;
|
|
6877
|
+
}, {
|
|
6878
|
+
filePath: string;
|
|
6879
|
+
startLine: number;
|
|
6880
|
+
endLine: number;
|
|
6881
|
+
newContent: string;
|
|
6882
|
+
createBackup?: boolean | undefined;
|
|
6883
|
+
}>, z.ZodObject<{
|
|
6884
|
+
success: z.ZodBoolean;
|
|
6885
|
+
message: z.ZodString;
|
|
6886
|
+
linesReplaced: z.ZodOptional<z.ZodNumber>;
|
|
6887
|
+
backup: z.ZodOptional<z.ZodString>;
|
|
6888
|
+
error: z.ZodOptional<z.ZodString>;
|
|
6889
|
+
}, "strip", z.ZodTypeAny, {
|
|
6890
|
+
message: string;
|
|
6891
|
+
success: boolean;
|
|
6892
|
+
error?: string | undefined;
|
|
6893
|
+
linesReplaced?: number | undefined;
|
|
6894
|
+
backup?: string | undefined;
|
|
6895
|
+
}, {
|
|
6896
|
+
message: string;
|
|
6897
|
+
success: boolean;
|
|
6898
|
+
error?: string | undefined;
|
|
6899
|
+
linesReplaced?: number | undefined;
|
|
6900
|
+
backup?: string | undefined;
|
|
6901
|
+
}>, ToolExecutionContext<z.ZodObject<{
|
|
6902
|
+
filePath: z.ZodString;
|
|
6903
|
+
startLine: z.ZodNumber;
|
|
6904
|
+
endLine: z.ZodNumber;
|
|
6905
|
+
newContent: z.ZodString;
|
|
6906
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
6907
|
+
}, "strip", z.ZodTypeAny, {
|
|
6908
|
+
createBackup: boolean;
|
|
6909
|
+
filePath: string;
|
|
6910
|
+
startLine: number;
|
|
6911
|
+
endLine: number;
|
|
6912
|
+
newContent: string;
|
|
6913
|
+
}, {
|
|
6914
|
+
filePath: string;
|
|
6915
|
+
startLine: number;
|
|
6916
|
+
endLine: number;
|
|
6917
|
+
newContent: string;
|
|
6918
|
+
createBackup?: boolean | undefined;
|
|
6919
|
+
}>>> & {
|
|
6920
|
+
inputSchema: z.ZodObject<{
|
|
6921
|
+
filePath: z.ZodString;
|
|
6922
|
+
startLine: z.ZodNumber;
|
|
6923
|
+
endLine: z.ZodNumber;
|
|
6924
|
+
newContent: z.ZodString;
|
|
6925
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
6926
|
+
}, "strip", z.ZodTypeAny, {
|
|
6927
|
+
createBackup: boolean;
|
|
6928
|
+
filePath: string;
|
|
6929
|
+
startLine: number;
|
|
6930
|
+
endLine: number;
|
|
6931
|
+
newContent: string;
|
|
6932
|
+
}, {
|
|
6933
|
+
filePath: string;
|
|
6934
|
+
startLine: number;
|
|
6935
|
+
endLine: number;
|
|
6936
|
+
newContent: string;
|
|
6937
|
+
createBackup?: boolean | undefined;
|
|
6938
|
+
}>;
|
|
6939
|
+
outputSchema: z.ZodObject<{
|
|
6940
|
+
success: z.ZodBoolean;
|
|
6941
|
+
message: z.ZodString;
|
|
6942
|
+
linesReplaced: z.ZodOptional<z.ZodNumber>;
|
|
6943
|
+
backup: z.ZodOptional<z.ZodString>;
|
|
6944
|
+
error: z.ZodOptional<z.ZodString>;
|
|
6945
|
+
}, "strip", z.ZodTypeAny, {
|
|
6946
|
+
message: string;
|
|
6947
|
+
success: boolean;
|
|
6948
|
+
error?: string | undefined;
|
|
6949
|
+
linesReplaced?: number | undefined;
|
|
6950
|
+
backup?: string | undefined;
|
|
6951
|
+
}, {
|
|
6952
|
+
message: string;
|
|
6953
|
+
success: boolean;
|
|
6954
|
+
error?: string | undefined;
|
|
6955
|
+
linesReplaced?: number | undefined;
|
|
6956
|
+
backup?: string | undefined;
|
|
6957
|
+
}>;
|
|
6958
|
+
execute: (context: ToolExecutionContext<z.ZodObject<{
|
|
6959
|
+
filePath: z.ZodString;
|
|
6960
|
+
startLine: z.ZodNumber;
|
|
6961
|
+
endLine: z.ZodNumber;
|
|
6962
|
+
newContent: z.ZodString;
|
|
6963
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
6964
|
+
}, "strip", z.ZodTypeAny, {
|
|
6965
|
+
createBackup: boolean;
|
|
6966
|
+
filePath: string;
|
|
6967
|
+
startLine: number;
|
|
6968
|
+
endLine: number;
|
|
6969
|
+
newContent: string;
|
|
6970
|
+
}, {
|
|
6971
|
+
filePath: string;
|
|
6972
|
+
startLine: number;
|
|
6973
|
+
endLine: number;
|
|
6974
|
+
newContent: string;
|
|
6975
|
+
createBackup?: boolean | undefined;
|
|
6976
|
+
}>>) => Promise<any>;
|
|
6977
|
+
};
|
|
6633
6978
|
askClarification: Tool<z.ZodObject<{
|
|
6634
6979
|
question: z.ZodString;
|
|
6635
6980
|
options: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -7679,13 +8024,13 @@ export declare class AgentBuilderDefaults {
|
|
|
7679
8024
|
includeTests: z.ZodDefault<z.ZodBoolean>;
|
|
7680
8025
|
}, "strip", z.ZodTypeAny, {
|
|
7681
8026
|
path: string;
|
|
7682
|
-
action: "
|
|
8027
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
7683
8028
|
depth: number;
|
|
7684
8029
|
includeTests: boolean;
|
|
7685
8030
|
language?: string | undefined;
|
|
7686
8031
|
}, {
|
|
7687
8032
|
path: string;
|
|
7688
|
-
action: "
|
|
8033
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
7689
8034
|
language?: string | undefined;
|
|
7690
8035
|
depth?: number | undefined;
|
|
7691
8036
|
includeTests?: boolean | undefined;
|
|
@@ -7718,13 +8063,13 @@ export declare class AgentBuilderDefaults {
|
|
|
7718
8063
|
target: z.ZodString;
|
|
7719
8064
|
}, "strip", z.ZodTypeAny, {
|
|
7720
8065
|
type: "import" | "require" | "include";
|
|
7721
|
-
name: string;
|
|
7722
8066
|
source: string;
|
|
8067
|
+
name: string;
|
|
7723
8068
|
target: string;
|
|
7724
8069
|
}, {
|
|
7725
8070
|
type: "import" | "require" | "include";
|
|
7726
|
-
name: string;
|
|
7727
8071
|
source: string;
|
|
8072
|
+
name: string;
|
|
7728
8073
|
target: string;
|
|
7729
8074
|
}>, "many">>;
|
|
7730
8075
|
patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -7757,6 +8102,12 @@ export declare class AgentBuilderDefaults {
|
|
|
7757
8102
|
complexity: string;
|
|
7758
8103
|
}>>;
|
|
7759
8104
|
}, "strip", z.ZodTypeAny, {
|
|
8105
|
+
dependencies?: {
|
|
8106
|
+
type: "import" | "require" | "include";
|
|
8107
|
+
source: string;
|
|
8108
|
+
name: string;
|
|
8109
|
+
target: string;
|
|
8110
|
+
}[] | undefined;
|
|
7760
8111
|
definitions?: {
|
|
7761
8112
|
type: string;
|
|
7762
8113
|
file: string;
|
|
@@ -7764,12 +8115,6 @@ export declare class AgentBuilderDefaults {
|
|
|
7764
8115
|
scope?: string | undefined;
|
|
7765
8116
|
line?: number | undefined;
|
|
7766
8117
|
}[] | undefined;
|
|
7767
|
-
dependencies?: {
|
|
7768
|
-
type: "import" | "require" | "include";
|
|
7769
|
-
name: string;
|
|
7770
|
-
source: string;
|
|
7771
|
-
target: string;
|
|
7772
|
-
}[] | undefined;
|
|
7773
8118
|
patterns?: {
|
|
7774
8119
|
description: string;
|
|
7775
8120
|
files: string[];
|
|
@@ -7782,6 +8127,12 @@ export declare class AgentBuilderDefaults {
|
|
|
7782
8127
|
complexity: string;
|
|
7783
8128
|
} | undefined;
|
|
7784
8129
|
}, {
|
|
8130
|
+
dependencies?: {
|
|
8131
|
+
type: "import" | "require" | "include";
|
|
8132
|
+
source: string;
|
|
8133
|
+
name: string;
|
|
8134
|
+
target: string;
|
|
8135
|
+
}[] | undefined;
|
|
7785
8136
|
definitions?: {
|
|
7786
8137
|
type: string;
|
|
7787
8138
|
file: string;
|
|
@@ -7789,12 +8140,6 @@ export declare class AgentBuilderDefaults {
|
|
|
7789
8140
|
scope?: string | undefined;
|
|
7790
8141
|
line?: number | undefined;
|
|
7791
8142
|
}[] | undefined;
|
|
7792
|
-
dependencies?: {
|
|
7793
|
-
type: "import" | "require" | "include";
|
|
7794
|
-
name: string;
|
|
7795
|
-
source: string;
|
|
7796
|
-
target: string;
|
|
7797
|
-
}[] | undefined;
|
|
7798
8143
|
patterns?: {
|
|
7799
8144
|
description: string;
|
|
7800
8145
|
files: string[];
|
|
@@ -7812,6 +8157,12 @@ export declare class AgentBuilderDefaults {
|
|
|
7812
8157
|
message: string;
|
|
7813
8158
|
success: boolean;
|
|
7814
8159
|
analysis: {
|
|
8160
|
+
dependencies?: {
|
|
8161
|
+
type: "import" | "require" | "include";
|
|
8162
|
+
source: string;
|
|
8163
|
+
name: string;
|
|
8164
|
+
target: string;
|
|
8165
|
+
}[] | undefined;
|
|
7815
8166
|
definitions?: {
|
|
7816
8167
|
type: string;
|
|
7817
8168
|
file: string;
|
|
@@ -7819,12 +8170,6 @@ export declare class AgentBuilderDefaults {
|
|
|
7819
8170
|
scope?: string | undefined;
|
|
7820
8171
|
line?: number | undefined;
|
|
7821
8172
|
}[] | undefined;
|
|
7822
|
-
dependencies?: {
|
|
7823
|
-
type: "import" | "require" | "include";
|
|
7824
|
-
name: string;
|
|
7825
|
-
source: string;
|
|
7826
|
-
target: string;
|
|
7827
|
-
}[] | undefined;
|
|
7828
8173
|
patterns?: {
|
|
7829
8174
|
description: string;
|
|
7830
8175
|
files: string[];
|
|
@@ -7841,6 +8186,12 @@ export declare class AgentBuilderDefaults {
|
|
|
7841
8186
|
message: string;
|
|
7842
8187
|
success: boolean;
|
|
7843
8188
|
analysis: {
|
|
8189
|
+
dependencies?: {
|
|
8190
|
+
type: "import" | "require" | "include";
|
|
8191
|
+
source: string;
|
|
8192
|
+
name: string;
|
|
8193
|
+
target: string;
|
|
8194
|
+
}[] | undefined;
|
|
7844
8195
|
definitions?: {
|
|
7845
8196
|
type: string;
|
|
7846
8197
|
file: string;
|
|
@@ -7848,12 +8199,6 @@ export declare class AgentBuilderDefaults {
|
|
|
7848
8199
|
scope?: string | undefined;
|
|
7849
8200
|
line?: number | undefined;
|
|
7850
8201
|
}[] | undefined;
|
|
7851
|
-
dependencies?: {
|
|
7852
|
-
type: "import" | "require" | "include";
|
|
7853
|
-
name: string;
|
|
7854
|
-
source: string;
|
|
7855
|
-
target: string;
|
|
7856
|
-
}[] | undefined;
|
|
7857
8202
|
patterns?: {
|
|
7858
8203
|
description: string;
|
|
7859
8204
|
files: string[];
|
|
@@ -7874,13 +8219,13 @@ export declare class AgentBuilderDefaults {
|
|
|
7874
8219
|
includeTests: z.ZodDefault<z.ZodBoolean>;
|
|
7875
8220
|
}, "strip", z.ZodTypeAny, {
|
|
7876
8221
|
path: string;
|
|
7877
|
-
action: "
|
|
8222
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
7878
8223
|
depth: number;
|
|
7879
8224
|
includeTests: boolean;
|
|
7880
8225
|
language?: string | undefined;
|
|
7881
8226
|
}, {
|
|
7882
8227
|
path: string;
|
|
7883
|
-
action: "
|
|
8228
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
7884
8229
|
language?: string | undefined;
|
|
7885
8230
|
depth?: number | undefined;
|
|
7886
8231
|
includeTests?: boolean | undefined;
|
|
@@ -7893,13 +8238,13 @@ export declare class AgentBuilderDefaults {
|
|
|
7893
8238
|
includeTests: z.ZodDefault<z.ZodBoolean>;
|
|
7894
8239
|
}, "strip", z.ZodTypeAny, {
|
|
7895
8240
|
path: string;
|
|
7896
|
-
action: "
|
|
8241
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
7897
8242
|
depth: number;
|
|
7898
8243
|
includeTests: boolean;
|
|
7899
8244
|
language?: string | undefined;
|
|
7900
8245
|
}, {
|
|
7901
8246
|
path: string;
|
|
7902
|
-
action: "
|
|
8247
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
7903
8248
|
language?: string | undefined;
|
|
7904
8249
|
depth?: number | undefined;
|
|
7905
8250
|
includeTests?: boolean | undefined;
|
|
@@ -7933,13 +8278,13 @@ export declare class AgentBuilderDefaults {
|
|
|
7933
8278
|
target: z.ZodString;
|
|
7934
8279
|
}, "strip", z.ZodTypeAny, {
|
|
7935
8280
|
type: "import" | "require" | "include";
|
|
7936
|
-
name: string;
|
|
7937
8281
|
source: string;
|
|
8282
|
+
name: string;
|
|
7938
8283
|
target: string;
|
|
7939
8284
|
}, {
|
|
7940
8285
|
type: "import" | "require" | "include";
|
|
7941
|
-
name: string;
|
|
7942
8286
|
source: string;
|
|
8287
|
+
name: string;
|
|
7943
8288
|
target: string;
|
|
7944
8289
|
}>, "many">>;
|
|
7945
8290
|
patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -7972,6 +8317,12 @@ export declare class AgentBuilderDefaults {
|
|
|
7972
8317
|
complexity: string;
|
|
7973
8318
|
}>>;
|
|
7974
8319
|
}, "strip", z.ZodTypeAny, {
|
|
8320
|
+
dependencies?: {
|
|
8321
|
+
type: "import" | "require" | "include";
|
|
8322
|
+
source: string;
|
|
8323
|
+
name: string;
|
|
8324
|
+
target: string;
|
|
8325
|
+
}[] | undefined;
|
|
7975
8326
|
definitions?: {
|
|
7976
8327
|
type: string;
|
|
7977
8328
|
file: string;
|
|
@@ -7979,12 +8330,6 @@ export declare class AgentBuilderDefaults {
|
|
|
7979
8330
|
scope?: string | undefined;
|
|
7980
8331
|
line?: number | undefined;
|
|
7981
8332
|
}[] | undefined;
|
|
7982
|
-
dependencies?: {
|
|
7983
|
-
type: "import" | "require" | "include";
|
|
7984
|
-
name: string;
|
|
7985
|
-
source: string;
|
|
7986
|
-
target: string;
|
|
7987
|
-
}[] | undefined;
|
|
7988
8333
|
patterns?: {
|
|
7989
8334
|
description: string;
|
|
7990
8335
|
files: string[];
|
|
@@ -7997,19 +8342,19 @@ export declare class AgentBuilderDefaults {
|
|
|
7997
8342
|
complexity: string;
|
|
7998
8343
|
} | undefined;
|
|
7999
8344
|
}, {
|
|
8000
|
-
definitions?: {
|
|
8001
|
-
type: string;
|
|
8002
|
-
file: string;
|
|
8003
|
-
name: string;
|
|
8004
|
-
scope?: string | undefined;
|
|
8005
|
-
line?: number | undefined;
|
|
8006
|
-
}[] | undefined;
|
|
8007
8345
|
dependencies?: {
|
|
8008
8346
|
type: "import" | "require" | "include";
|
|
8009
|
-
name: string;
|
|
8010
8347
|
source: string;
|
|
8348
|
+
name: string;
|
|
8011
8349
|
target: string;
|
|
8012
8350
|
}[] | undefined;
|
|
8351
|
+
definitions?: {
|
|
8352
|
+
type: string;
|
|
8353
|
+
file: string;
|
|
8354
|
+
name: string;
|
|
8355
|
+
scope?: string | undefined;
|
|
8356
|
+
line?: number | undefined;
|
|
8357
|
+
}[] | undefined;
|
|
8013
8358
|
patterns?: {
|
|
8014
8359
|
description: string;
|
|
8015
8360
|
files: string[];
|
|
@@ -8027,6 +8372,12 @@ export declare class AgentBuilderDefaults {
|
|
|
8027
8372
|
message: string;
|
|
8028
8373
|
success: boolean;
|
|
8029
8374
|
analysis: {
|
|
8375
|
+
dependencies?: {
|
|
8376
|
+
type: "import" | "require" | "include";
|
|
8377
|
+
source: string;
|
|
8378
|
+
name: string;
|
|
8379
|
+
target: string;
|
|
8380
|
+
}[] | undefined;
|
|
8030
8381
|
definitions?: {
|
|
8031
8382
|
type: string;
|
|
8032
8383
|
file: string;
|
|
@@ -8034,12 +8385,6 @@ export declare class AgentBuilderDefaults {
|
|
|
8034
8385
|
scope?: string | undefined;
|
|
8035
8386
|
line?: number | undefined;
|
|
8036
8387
|
}[] | undefined;
|
|
8037
|
-
dependencies?: {
|
|
8038
|
-
type: "import" | "require" | "include";
|
|
8039
|
-
name: string;
|
|
8040
|
-
source: string;
|
|
8041
|
-
target: string;
|
|
8042
|
-
}[] | undefined;
|
|
8043
8388
|
patterns?: {
|
|
8044
8389
|
description: string;
|
|
8045
8390
|
files: string[];
|
|
@@ -8056,6 +8401,12 @@ export declare class AgentBuilderDefaults {
|
|
|
8056
8401
|
message: string;
|
|
8057
8402
|
success: boolean;
|
|
8058
8403
|
analysis: {
|
|
8404
|
+
dependencies?: {
|
|
8405
|
+
type: "import" | "require" | "include";
|
|
8406
|
+
source: string;
|
|
8407
|
+
name: string;
|
|
8408
|
+
target: string;
|
|
8409
|
+
}[] | undefined;
|
|
8059
8410
|
definitions?: {
|
|
8060
8411
|
type: string;
|
|
8061
8412
|
file: string;
|
|
@@ -8063,12 +8414,6 @@ export declare class AgentBuilderDefaults {
|
|
|
8063
8414
|
scope?: string | undefined;
|
|
8064
8415
|
line?: number | undefined;
|
|
8065
8416
|
}[] | undefined;
|
|
8066
|
-
dependencies?: {
|
|
8067
|
-
type: "import" | "require" | "include";
|
|
8068
|
-
name: string;
|
|
8069
|
-
source: string;
|
|
8070
|
-
target: string;
|
|
8071
|
-
}[] | undefined;
|
|
8072
8417
|
patterns?: {
|
|
8073
8418
|
description: string;
|
|
8074
8419
|
files: string[];
|
|
@@ -8090,13 +8435,13 @@ export declare class AgentBuilderDefaults {
|
|
|
8090
8435
|
includeTests: z.ZodDefault<z.ZodBoolean>;
|
|
8091
8436
|
}, "strip", z.ZodTypeAny, {
|
|
8092
8437
|
path: string;
|
|
8093
|
-
action: "
|
|
8438
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
8094
8439
|
depth: number;
|
|
8095
8440
|
includeTests: boolean;
|
|
8096
8441
|
language?: string | undefined;
|
|
8097
8442
|
}, {
|
|
8098
8443
|
path: string;
|
|
8099
|
-
action: "
|
|
8444
|
+
action: "dependencies" | "definitions" | "patterns" | "structure";
|
|
8100
8445
|
language?: string | undefined;
|
|
8101
8446
|
depth?: number | undefined;
|
|
8102
8447
|
includeTests?: boolean | undefined;
|
|
@@ -9719,14 +10064,14 @@ export declare class AgentBuilderDefaults {
|
|
|
9719
10064
|
errors: z.ZodArray<z.ZodString, "many">;
|
|
9720
10065
|
backup: z.ZodOptional<z.ZodString>;
|
|
9721
10066
|
}, "strip", z.ZodTypeAny, {
|
|
10067
|
+
errors: string[];
|
|
9722
10068
|
filePath: string;
|
|
9723
10069
|
editsApplied: number;
|
|
9724
|
-
errors: string[];
|
|
9725
10070
|
backup?: string | undefined;
|
|
9726
10071
|
}, {
|
|
10072
|
+
errors: string[];
|
|
9727
10073
|
filePath: string;
|
|
9728
10074
|
editsApplied: number;
|
|
9729
|
-
errors: string[];
|
|
9730
10075
|
backup?: string | undefined;
|
|
9731
10076
|
}>, "many">;
|
|
9732
10077
|
message: z.ZodString;
|
|
@@ -9734,18 +10079,18 @@ export declare class AgentBuilderDefaults {
|
|
|
9734
10079
|
message: string;
|
|
9735
10080
|
success: boolean;
|
|
9736
10081
|
results: {
|
|
10082
|
+
errors: string[];
|
|
9737
10083
|
filePath: string;
|
|
9738
10084
|
editsApplied: number;
|
|
9739
|
-
errors: string[];
|
|
9740
10085
|
backup?: string | undefined;
|
|
9741
10086
|
}[];
|
|
9742
10087
|
}, {
|
|
9743
10088
|
message: string;
|
|
9744
10089
|
success: boolean;
|
|
9745
10090
|
results: {
|
|
10091
|
+
errors: string[];
|
|
9746
10092
|
filePath: string;
|
|
9747
10093
|
editsApplied: number;
|
|
9748
|
-
errors: string[];
|
|
9749
10094
|
backup?: string | undefined;
|
|
9750
10095
|
}[];
|
|
9751
10096
|
}>, ToolExecutionContext<z.ZodObject<{
|
|
@@ -9862,14 +10207,14 @@ export declare class AgentBuilderDefaults {
|
|
|
9862
10207
|
errors: z.ZodArray<z.ZodString, "many">;
|
|
9863
10208
|
backup: z.ZodOptional<z.ZodString>;
|
|
9864
10209
|
}, "strip", z.ZodTypeAny, {
|
|
10210
|
+
errors: string[];
|
|
9865
10211
|
filePath: string;
|
|
9866
10212
|
editsApplied: number;
|
|
9867
|
-
errors: string[];
|
|
9868
10213
|
backup?: string | undefined;
|
|
9869
10214
|
}, {
|
|
10215
|
+
errors: string[];
|
|
9870
10216
|
filePath: string;
|
|
9871
10217
|
editsApplied: number;
|
|
9872
|
-
errors: string[];
|
|
9873
10218
|
backup?: string | undefined;
|
|
9874
10219
|
}>, "many">;
|
|
9875
10220
|
message: z.ZodString;
|
|
@@ -9877,18 +10222,18 @@ export declare class AgentBuilderDefaults {
|
|
|
9877
10222
|
message: string;
|
|
9878
10223
|
success: boolean;
|
|
9879
10224
|
results: {
|
|
10225
|
+
errors: string[];
|
|
9880
10226
|
filePath: string;
|
|
9881
10227
|
editsApplied: number;
|
|
9882
|
-
errors: string[];
|
|
9883
10228
|
backup?: string | undefined;
|
|
9884
10229
|
}[];
|
|
9885
10230
|
}, {
|
|
9886
10231
|
message: string;
|
|
9887
10232
|
success: boolean;
|
|
9888
10233
|
results: {
|
|
10234
|
+
errors: string[];
|
|
9889
10235
|
filePath: string;
|
|
9890
10236
|
editsApplied: number;
|
|
9891
|
-
errors: string[];
|
|
9892
10237
|
backup?: string | undefined;
|
|
9893
10238
|
}[];
|
|
9894
10239
|
}>;
|
|
@@ -9946,6 +10291,119 @@ export declare class AgentBuilderDefaults {
|
|
|
9946
10291
|
createBackup?: boolean | undefined;
|
|
9947
10292
|
}>>) => Promise<any>;
|
|
9948
10293
|
};
|
|
10294
|
+
replaceLines: Tool<z.ZodObject<{
|
|
10295
|
+
filePath: z.ZodString;
|
|
10296
|
+
startLine: z.ZodNumber;
|
|
10297
|
+
endLine: z.ZodNumber;
|
|
10298
|
+
newContent: z.ZodString;
|
|
10299
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
10300
|
+
}, "strip", z.ZodTypeAny, {
|
|
10301
|
+
createBackup: boolean;
|
|
10302
|
+
filePath: string;
|
|
10303
|
+
startLine: number;
|
|
10304
|
+
endLine: number;
|
|
10305
|
+
newContent: string;
|
|
10306
|
+
}, {
|
|
10307
|
+
filePath: string;
|
|
10308
|
+
startLine: number;
|
|
10309
|
+
endLine: number;
|
|
10310
|
+
newContent: string;
|
|
10311
|
+
createBackup?: boolean | undefined;
|
|
10312
|
+
}>, z.ZodObject<{
|
|
10313
|
+
success: z.ZodBoolean;
|
|
10314
|
+
message: z.ZodString;
|
|
10315
|
+
linesReplaced: z.ZodOptional<z.ZodNumber>;
|
|
10316
|
+
backup: z.ZodOptional<z.ZodString>;
|
|
10317
|
+
error: z.ZodOptional<z.ZodString>;
|
|
10318
|
+
}, "strip", z.ZodTypeAny, {
|
|
10319
|
+
message: string;
|
|
10320
|
+
success: boolean;
|
|
10321
|
+
error?: string | undefined;
|
|
10322
|
+
linesReplaced?: number | undefined;
|
|
10323
|
+
backup?: string | undefined;
|
|
10324
|
+
}, {
|
|
10325
|
+
message: string;
|
|
10326
|
+
success: boolean;
|
|
10327
|
+
error?: string | undefined;
|
|
10328
|
+
linesReplaced?: number | undefined;
|
|
10329
|
+
backup?: string | undefined;
|
|
10330
|
+
}>, ToolExecutionContext<z.ZodObject<{
|
|
10331
|
+
filePath: z.ZodString;
|
|
10332
|
+
startLine: z.ZodNumber;
|
|
10333
|
+
endLine: z.ZodNumber;
|
|
10334
|
+
newContent: z.ZodString;
|
|
10335
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
10336
|
+
}, "strip", z.ZodTypeAny, {
|
|
10337
|
+
createBackup: boolean;
|
|
10338
|
+
filePath: string;
|
|
10339
|
+
startLine: number;
|
|
10340
|
+
endLine: number;
|
|
10341
|
+
newContent: string;
|
|
10342
|
+
}, {
|
|
10343
|
+
filePath: string;
|
|
10344
|
+
startLine: number;
|
|
10345
|
+
endLine: number;
|
|
10346
|
+
newContent: string;
|
|
10347
|
+
createBackup?: boolean | undefined;
|
|
10348
|
+
}>>> & {
|
|
10349
|
+
inputSchema: z.ZodObject<{
|
|
10350
|
+
filePath: z.ZodString;
|
|
10351
|
+
startLine: z.ZodNumber;
|
|
10352
|
+
endLine: z.ZodNumber;
|
|
10353
|
+
newContent: z.ZodString;
|
|
10354
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
10355
|
+
}, "strip", z.ZodTypeAny, {
|
|
10356
|
+
createBackup: boolean;
|
|
10357
|
+
filePath: string;
|
|
10358
|
+
startLine: number;
|
|
10359
|
+
endLine: number;
|
|
10360
|
+
newContent: string;
|
|
10361
|
+
}, {
|
|
10362
|
+
filePath: string;
|
|
10363
|
+
startLine: number;
|
|
10364
|
+
endLine: number;
|
|
10365
|
+
newContent: string;
|
|
10366
|
+
createBackup?: boolean | undefined;
|
|
10367
|
+
}>;
|
|
10368
|
+
outputSchema: z.ZodObject<{
|
|
10369
|
+
success: z.ZodBoolean;
|
|
10370
|
+
message: z.ZodString;
|
|
10371
|
+
linesReplaced: z.ZodOptional<z.ZodNumber>;
|
|
10372
|
+
backup: z.ZodOptional<z.ZodString>;
|
|
10373
|
+
error: z.ZodOptional<z.ZodString>;
|
|
10374
|
+
}, "strip", z.ZodTypeAny, {
|
|
10375
|
+
message: string;
|
|
10376
|
+
success: boolean;
|
|
10377
|
+
error?: string | undefined;
|
|
10378
|
+
linesReplaced?: number | undefined;
|
|
10379
|
+
backup?: string | undefined;
|
|
10380
|
+
}, {
|
|
10381
|
+
message: string;
|
|
10382
|
+
success: boolean;
|
|
10383
|
+
error?: string | undefined;
|
|
10384
|
+
linesReplaced?: number | undefined;
|
|
10385
|
+
backup?: string | undefined;
|
|
10386
|
+
}>;
|
|
10387
|
+
execute: (context: ToolExecutionContext<z.ZodObject<{
|
|
10388
|
+
filePath: z.ZodString;
|
|
10389
|
+
startLine: z.ZodNumber;
|
|
10390
|
+
endLine: z.ZodNumber;
|
|
10391
|
+
newContent: z.ZodString;
|
|
10392
|
+
createBackup: z.ZodDefault<z.ZodBoolean>;
|
|
10393
|
+
}, "strip", z.ZodTypeAny, {
|
|
10394
|
+
createBackup: boolean;
|
|
10395
|
+
filePath: string;
|
|
10396
|
+
startLine: number;
|
|
10397
|
+
endLine: number;
|
|
10398
|
+
newContent: string;
|
|
10399
|
+
}, {
|
|
10400
|
+
filePath: string;
|
|
10401
|
+
startLine: number;
|
|
10402
|
+
endLine: number;
|
|
10403
|
+
newContent: string;
|
|
10404
|
+
createBackup?: boolean | undefined;
|
|
10405
|
+
}>>) => Promise<any>;
|
|
10406
|
+
};
|
|
9949
10407
|
askClarification: Tool<z.ZodObject<{
|
|
9950
10408
|
question: z.ZodString;
|
|
9951
10409
|
options: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -10854,6 +11312,11 @@ export declare class AgentBuilderDefaults {
|
|
|
10854
11312
|
port?: number;
|
|
10855
11313
|
projectPath?: string;
|
|
10856
11314
|
}): Promise<{
|
|
11315
|
+
success: boolean;
|
|
11316
|
+
status: "error";
|
|
11317
|
+
error: string;
|
|
11318
|
+
message?: undefined;
|
|
11319
|
+
} | {
|
|
10857
11320
|
success: boolean;
|
|
10858
11321
|
status: "stopped";
|
|
10859
11322
|
message: string;
|
|
@@ -11061,6 +11524,29 @@ export declare class AgentBuilderDefaults {
|
|
|
11061
11524
|
}[];
|
|
11062
11525
|
message: string;
|
|
11063
11526
|
}>;
|
|
11527
|
+
/**
|
|
11528
|
+
* Replace specific line ranges in a file with new content
|
|
11529
|
+
*/
|
|
11530
|
+
static replaceLines(context: {
|
|
11531
|
+
filePath: string;
|
|
11532
|
+
startLine: number;
|
|
11533
|
+
endLine: number;
|
|
11534
|
+
newContent: string;
|
|
11535
|
+
createBackup?: boolean;
|
|
11536
|
+
projectPath?: string;
|
|
11537
|
+
}): Promise<{
|
|
11538
|
+
success: boolean;
|
|
11539
|
+
message: string;
|
|
11540
|
+
error: string;
|
|
11541
|
+
linesReplaced?: undefined;
|
|
11542
|
+
backup?: undefined;
|
|
11543
|
+
} | {
|
|
11544
|
+
success: boolean;
|
|
11545
|
+
message: string;
|
|
11546
|
+
linesReplaced: number;
|
|
11547
|
+
backup: string | undefined;
|
|
11548
|
+
error?: undefined;
|
|
11549
|
+
}>;
|
|
11064
11550
|
/**
|
|
11065
11551
|
* Ask user for clarification
|
|
11066
11552
|
*/
|
|
@@ -11121,7 +11607,7 @@ export declare class AgentBuilderDefaults {
|
|
|
11121
11607
|
afterLines?: number;
|
|
11122
11608
|
includeDefinitions?: boolean;
|
|
11123
11609
|
};
|
|
11124
|
-
}): Promise<{
|
|
11610
|
+
}, projectPath: string): Promise<{
|
|
11125
11611
|
success: boolean;
|
|
11126
11612
|
matches: {
|
|
11127
11613
|
file: string;
|
|
@@ -11288,65 +11774,10 @@ export declare class AgentBuilderDefaults {
|
|
|
11288
11774
|
suggestions?: undefined;
|
|
11289
11775
|
}>;
|
|
11290
11776
|
}
|
|
11777
|
+
export { AgentBuilderDefaults }
|
|
11778
|
+
export { AgentBuilderDefaults as AgentBuilderDefaults_alias_1 }
|
|
11291
11779
|
|
|
11292
|
-
export declare const
|
|
11293
|
-
success: z.ZodBoolean;
|
|
11294
|
-
applied: z.ZodBoolean;
|
|
11295
|
-
branchName: z.ZodOptional<z.ZodString>;
|
|
11296
|
-
error: z.ZodOptional<z.ZodString>;
|
|
11297
|
-
}, "strip", z.ZodTypeAny, {
|
|
11298
|
-
success: boolean;
|
|
11299
|
-
applied: boolean;
|
|
11300
|
-
branchName?: string | undefined;
|
|
11301
|
-
error?: string | undefined;
|
|
11302
|
-
}, {
|
|
11303
|
-
success: boolean;
|
|
11304
|
-
applied: boolean;
|
|
11305
|
-
branchName?: string | undefined;
|
|
11306
|
-
error?: string | undefined;
|
|
11307
|
-
}>;
|
|
11308
|
-
|
|
11309
|
-
export declare function backupAndReplaceFile(sourceFile: string, targetFile: string): Promise<void>;
|
|
11310
|
-
|
|
11311
|
-
export declare const exec: typeof exec_2.__promisify__;
|
|
11312
|
-
|
|
11313
|
-
export declare function fetchMastraTemplates(): Promise<Array<{
|
|
11314
|
-
slug: string;
|
|
11315
|
-
title: string;
|
|
11316
|
-
description: string;
|
|
11317
|
-
githubUrl: string;
|
|
11318
|
-
tags: string[];
|
|
11319
|
-
agents: string[];
|
|
11320
|
-
workflows: string[];
|
|
11321
|
-
tools: string[];
|
|
11322
|
-
}>>;
|
|
11323
|
-
|
|
11324
|
-
/**
|
|
11325
|
-
* Options for generating agents with AgentBuilder
|
|
11326
|
-
*/
|
|
11327
|
-
export declare interface GenerateAgentOptions {
|
|
11328
|
-
/** Runtime context for the generation */
|
|
11329
|
-
runtimeContext?: any;
|
|
11330
|
-
/** Output format preference */
|
|
11331
|
-
outputFormat?: 'code' | 'explanation' | 'both';
|
|
11332
|
-
}
|
|
11333
|
-
|
|
11334
|
-
export declare function getMastraTemplate(slug: string): Promise<{
|
|
11335
|
-
slug: string;
|
|
11336
|
-
title: string;
|
|
11337
|
-
description: string;
|
|
11338
|
-
githubUrl: string;
|
|
11339
|
-
tags: string[];
|
|
11340
|
-
agents: string[];
|
|
11341
|
-
workflows: string[];
|
|
11342
|
-
tools: string[];
|
|
11343
|
-
}>;
|
|
11344
|
-
|
|
11345
|
-
export declare function kindWeight(kind: UnitKind): number;
|
|
11346
|
-
|
|
11347
|
-
export declare function logGitState(targetPath: string, label: string): Promise<void>;
|
|
11348
|
-
|
|
11349
|
-
export declare const MergeInputSchema: z.ZodObject<{
|
|
11780
|
+
export declare const AgentBuilderInputSchema: z.ZodObject<{
|
|
11350
11781
|
repo: z.ZodString;
|
|
11351
11782
|
ref: z.ZodOptional<z.ZodString>;
|
|
11352
11783
|
slug: z.ZodOptional<z.ZodString>;
|
|
@@ -11363,75 +11794,16 @@ export declare const MergeInputSchema: z.ZodObject<{
|
|
|
11363
11794
|
targetPath?: string | undefined;
|
|
11364
11795
|
}>;
|
|
11365
11796
|
|
|
11366
|
-
|
|
11367
|
-
|
|
11368
|
-
|
|
11369
|
-
|
|
11370
|
-
|
|
11371
|
-
}
|
|
11372
|
-
|
|
11373
|
-
export declare const MergePlanSchema: z.ZodObject<{
|
|
11374
|
-
slug: z.ZodString;
|
|
11375
|
-
commitSha: z.ZodString;
|
|
11376
|
-
templateDir: z.ZodString;
|
|
11377
|
-
units: z.ZodArray<z.ZodObject<{
|
|
11378
|
-
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
11379
|
-
id: z.ZodString;
|
|
11380
|
-
file: z.ZodString;
|
|
11381
|
-
}, "strip", z.ZodTypeAny, {
|
|
11382
|
-
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11383
|
-
id: string;
|
|
11384
|
-
file: string;
|
|
11385
|
-
}, {
|
|
11386
|
-
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11387
|
-
id: string;
|
|
11388
|
-
file: string;
|
|
11389
|
-
}>, "many">;
|
|
11797
|
+
declare const agentBuilderTemplateWorkflow: Workflow<DefaultEngineType, (Step<"clone-template", z.ZodObject<{
|
|
11798
|
+
repo: z.ZodString;
|
|
11799
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
11800
|
+
slug: z.ZodOptional<z.ZodString>;
|
|
11801
|
+
targetPath: z.ZodOptional<z.ZodString>;
|
|
11390
11802
|
}, "strip", z.ZodTypeAny, {
|
|
11391
|
-
|
|
11392
|
-
|
|
11393
|
-
|
|
11394
|
-
|
|
11395
|
-
file: string;
|
|
11396
|
-
}[];
|
|
11397
|
-
commitSha: string;
|
|
11398
|
-
templateDir: string;
|
|
11399
|
-
}, {
|
|
11400
|
-
slug: string;
|
|
11401
|
-
units: {
|
|
11402
|
-
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11403
|
-
id: string;
|
|
11404
|
-
file: string;
|
|
11405
|
-
}[];
|
|
11406
|
-
commitSha: string;
|
|
11407
|
-
templateDir: string;
|
|
11408
|
-
}>;
|
|
11409
|
-
|
|
11410
|
-
export declare function mergeTemplateBySlug(slug: string, targetPath?: string): Promise<WorkflowResult<z.ZodObject<{
|
|
11411
|
-
success: z.ZodBoolean;
|
|
11412
|
-
applied: z.ZodBoolean;
|
|
11413
|
-
branchName: z.ZodOptional<z.ZodString>;
|
|
11414
|
-
error: z.ZodOptional<z.ZodString>;
|
|
11415
|
-
}, "strip", z.ZodTypeAny, {
|
|
11416
|
-
success: boolean;
|
|
11417
|
-
applied: boolean;
|
|
11418
|
-
branchName?: string | undefined;
|
|
11419
|
-
error?: string | undefined;
|
|
11420
|
-
}, {
|
|
11421
|
-
success: boolean;
|
|
11422
|
-
applied: boolean;
|
|
11423
|
-
branchName?: string | undefined;
|
|
11424
|
-
error?: string | undefined;
|
|
11425
|
-
}>, (Step<"clone-template", z.ZodObject<{
|
|
11426
|
-
repo: z.ZodString;
|
|
11427
|
-
ref: z.ZodOptional<z.ZodString>;
|
|
11428
|
-
slug: z.ZodOptional<z.ZodString>;
|
|
11429
|
-
targetPath: z.ZodOptional<z.ZodString>;
|
|
11430
|
-
}, "strip", z.ZodTypeAny, {
|
|
11431
|
-
repo: string;
|
|
11432
|
-
slug?: string | undefined;
|
|
11433
|
-
ref?: string | undefined;
|
|
11434
|
-
targetPath?: string | undefined;
|
|
11803
|
+
repo: string;
|
|
11804
|
+
slug?: string | undefined;
|
|
11805
|
+
ref?: string | undefined;
|
|
11806
|
+
targetPath?: string | undefined;
|
|
11435
11807
|
}, {
|
|
11436
11808
|
repo: string;
|
|
11437
11809
|
slug?: string | undefined;
|
|
@@ -11441,60 +11813,64 @@ targetPath?: string | undefined;
|
|
|
11441
11813
|
templateDir: z.ZodString;
|
|
11442
11814
|
commitSha: z.ZodString;
|
|
11443
11815
|
slug: z.ZodString;
|
|
11816
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
11817
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11444
11818
|
}, "strip", z.ZodTypeAny, {
|
|
11445
11819
|
slug: string;
|
|
11446
11820
|
commitSha: string;
|
|
11447
11821
|
templateDir: string;
|
|
11822
|
+
success?: boolean | undefined;
|
|
11823
|
+
error?: string | undefined;
|
|
11448
11824
|
}, {
|
|
11449
11825
|
slug: string;
|
|
11450
11826
|
commitSha: string;
|
|
11451
11827
|
templateDir: string;
|
|
11828
|
+
success?: boolean | undefined;
|
|
11829
|
+
error?: string | undefined;
|
|
11452
11830
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"analyze-package", z.ZodObject<{
|
|
11453
11831
|
templateDir: z.ZodString;
|
|
11454
11832
|
commitSha: z.ZodString;
|
|
11455
11833
|
slug: z.ZodString;
|
|
11834
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
11835
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11456
11836
|
}, "strip", z.ZodTypeAny, {
|
|
11457
11837
|
slug: string;
|
|
11458
11838
|
commitSha: string;
|
|
11459
11839
|
templateDir: string;
|
|
11840
|
+
success?: boolean | undefined;
|
|
11841
|
+
error?: string | undefined;
|
|
11460
11842
|
}, {
|
|
11461
11843
|
slug: string;
|
|
11462
11844
|
commitSha: string;
|
|
11463
11845
|
templateDir: string;
|
|
11846
|
+
success?: boolean | undefined;
|
|
11847
|
+
error?: string | undefined;
|
|
11464
11848
|
}>, z.ZodObject<{
|
|
11849
|
+
name: z.ZodOptional<z.ZodString>;
|
|
11850
|
+
version: z.ZodOptional<z.ZodString>;
|
|
11851
|
+
description: z.ZodOptional<z.ZodString>;
|
|
11465
11852
|
dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11466
11853
|
devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11467
11854
|
peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11468
11855
|
scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11469
|
-
|
|
11470
|
-
|
|
11471
|
-
version: z.ZodOptional<z.ZodString>;
|
|
11472
|
-
description: z.ZodOptional<z.ZodString>;
|
|
11473
|
-
}, "strip", z.ZodTypeAny, {
|
|
11474
|
-
description?: string | undefined;
|
|
11475
|
-
name?: string | undefined;
|
|
11476
|
-
version?: string | undefined;
|
|
11477
|
-
}, {
|
|
11478
|
-
description?: string | undefined;
|
|
11479
|
-
name?: string | undefined;
|
|
11480
|
-
version?: string | undefined;
|
|
11481
|
-
}>;
|
|
11856
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
11857
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11482
11858
|
}, "strip", z.ZodTypeAny, {
|
|
11483
|
-
packageInfo: {
|
|
11484
11859
|
description?: string | undefined;
|
|
11860
|
+
success?: boolean | undefined;
|
|
11861
|
+
error?: string | undefined;
|
|
11485
11862
|
name?: string | undefined;
|
|
11486
11863
|
version?: string | undefined;
|
|
11487
|
-
};
|
|
11488
11864
|
dependencies?: Record<string, string> | undefined;
|
|
11489
11865
|
devDependencies?: Record<string, string> | undefined;
|
|
11490
11866
|
peerDependencies?: Record<string, string> | undefined;
|
|
11491
11867
|
scripts?: Record<string, string> | undefined;
|
|
11492
11868
|
}, {
|
|
11493
|
-
packageInfo: {
|
|
11494
11869
|
description?: string | undefined;
|
|
11870
|
+
success?: boolean | undefined;
|
|
11871
|
+
error?: string | undefined;
|
|
11495
11872
|
name?: string | undefined;
|
|
11496
11873
|
version?: string | undefined;
|
|
11497
|
-
};
|
|
11498
11874
|
dependencies?: Record<string, string> | undefined;
|
|
11499
11875
|
devDependencies?: Record<string, string> | undefined;
|
|
11500
11876
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -11503,14 +11879,20 @@ scripts?: Record<string, string> | undefined;
|
|
|
11503
11879
|
templateDir: z.ZodString;
|
|
11504
11880
|
commitSha: z.ZodString;
|
|
11505
11881
|
slug: z.ZodString;
|
|
11882
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
11883
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11506
11884
|
}, "strip", z.ZodTypeAny, {
|
|
11507
11885
|
slug: string;
|
|
11508
11886
|
commitSha: string;
|
|
11509
11887
|
templateDir: string;
|
|
11888
|
+
success?: boolean | undefined;
|
|
11889
|
+
error?: string | undefined;
|
|
11510
11890
|
}, {
|
|
11511
11891
|
slug: string;
|
|
11512
11892
|
commitSha: string;
|
|
11513
11893
|
templateDir: string;
|
|
11894
|
+
success?: boolean | undefined;
|
|
11895
|
+
error?: string | undefined;
|
|
11514
11896
|
}>, z.ZodObject<{
|
|
11515
11897
|
units: z.ZodArray<z.ZodObject<{
|
|
11516
11898
|
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
@@ -11525,18 +11907,24 @@ kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" |
|
|
|
11525
11907
|
id: string;
|
|
11526
11908
|
file: string;
|
|
11527
11909
|
}>, "many">;
|
|
11910
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
11911
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11528
11912
|
}, "strip", z.ZodTypeAny, {
|
|
11529
11913
|
units: {
|
|
11530
11914
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11531
11915
|
id: string;
|
|
11532
11916
|
file: string;
|
|
11533
11917
|
}[];
|
|
11918
|
+
success?: boolean | undefined;
|
|
11919
|
+
error?: string | undefined;
|
|
11534
11920
|
}, {
|
|
11535
11921
|
units: {
|
|
11536
11922
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11537
11923
|
id: string;
|
|
11538
11924
|
file: string;
|
|
11539
11925
|
}[];
|
|
11926
|
+
success?: boolean | undefined;
|
|
11927
|
+
error?: string | undefined;
|
|
11540
11928
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"order-units", z.ZodObject<{
|
|
11541
11929
|
units: z.ZodArray<z.ZodObject<{
|
|
11542
11930
|
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
@@ -11551,18 +11939,24 @@ kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" |
|
|
|
11551
11939
|
id: string;
|
|
11552
11940
|
file: string;
|
|
11553
11941
|
}>, "many">;
|
|
11942
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
11943
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11554
11944
|
}, "strip", z.ZodTypeAny, {
|
|
11555
11945
|
units: {
|
|
11556
11946
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11557
11947
|
id: string;
|
|
11558
11948
|
file: string;
|
|
11559
11949
|
}[];
|
|
11950
|
+
success?: boolean | undefined;
|
|
11951
|
+
error?: string | undefined;
|
|
11560
11952
|
}, {
|
|
11561
11953
|
units: {
|
|
11562
11954
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11563
11955
|
id: string;
|
|
11564
11956
|
file: string;
|
|
11565
11957
|
}[];
|
|
11958
|
+
success?: boolean | undefined;
|
|
11959
|
+
error?: string | undefined;
|
|
11566
11960
|
}>, z.ZodObject<{
|
|
11567
11961
|
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
11568
11962
|
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
@@ -11577,56 +11971,54 @@ kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" |
|
|
|
11577
11971
|
id: string;
|
|
11578
11972
|
file: string;
|
|
11579
11973
|
}>, "many">;
|
|
11974
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
11975
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11580
11976
|
}, "strip", z.ZodTypeAny, {
|
|
11581
11977
|
orderedUnits: {
|
|
11582
11978
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11583
11979
|
id: string;
|
|
11584
11980
|
file: string;
|
|
11585
11981
|
}[];
|
|
11982
|
+
success?: boolean | undefined;
|
|
11983
|
+
error?: string | undefined;
|
|
11586
11984
|
}, {
|
|
11587
11985
|
orderedUnits: {
|
|
11588
11986
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11589
11987
|
id: string;
|
|
11590
11988
|
file: string;
|
|
11591
11989
|
}[];
|
|
11990
|
+
success?: boolean | undefined;
|
|
11991
|
+
error?: string | undefined;
|
|
11592
11992
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"package-merge", z.ZodObject<{
|
|
11593
11993
|
commitSha: z.ZodString;
|
|
11594
11994
|
slug: z.ZodString;
|
|
11595
11995
|
targetPath: z.ZodOptional<z.ZodString>;
|
|
11596
11996
|
packageInfo: z.ZodObject<{
|
|
11997
|
+
name: z.ZodOptional<z.ZodString>;
|
|
11998
|
+
version: z.ZodOptional<z.ZodString>;
|
|
11999
|
+
description: z.ZodOptional<z.ZodString>;
|
|
11597
12000
|
dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11598
12001
|
devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11599
12002
|
peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11600
12003
|
scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
11601
|
-
|
|
11602
|
-
|
|
11603
|
-
version: z.ZodOptional<z.ZodString>;
|
|
11604
|
-
description: z.ZodOptional<z.ZodString>;
|
|
11605
|
-
}, "strip", z.ZodTypeAny, {
|
|
11606
|
-
description?: string | undefined;
|
|
11607
|
-
name?: string | undefined;
|
|
11608
|
-
version?: string | undefined;
|
|
11609
|
-
}, {
|
|
11610
|
-
description?: string | undefined;
|
|
11611
|
-
name?: string | undefined;
|
|
11612
|
-
version?: string | undefined;
|
|
11613
|
-
}>;
|
|
12004
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
12005
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11614
12006
|
}, "strip", z.ZodTypeAny, {
|
|
11615
|
-
packageInfo: {
|
|
11616
12007
|
description?: string | undefined;
|
|
12008
|
+
success?: boolean | undefined;
|
|
12009
|
+
error?: string | undefined;
|
|
11617
12010
|
name?: string | undefined;
|
|
11618
12011
|
version?: string | undefined;
|
|
11619
|
-
};
|
|
11620
12012
|
dependencies?: Record<string, string> | undefined;
|
|
11621
12013
|
devDependencies?: Record<string, string> | undefined;
|
|
11622
12014
|
peerDependencies?: Record<string, string> | undefined;
|
|
11623
12015
|
scripts?: Record<string, string> | undefined;
|
|
11624
12016
|
}, {
|
|
11625
|
-
packageInfo: {
|
|
11626
12017
|
description?: string | undefined;
|
|
12018
|
+
success?: boolean | undefined;
|
|
12019
|
+
error?: string | undefined;
|
|
11627
12020
|
name?: string | undefined;
|
|
11628
12021
|
version?: string | undefined;
|
|
11629
|
-
};
|
|
11630
12022
|
dependencies?: Record<string, string> | undefined;
|
|
11631
12023
|
devDependencies?: Record<string, string> | undefined;
|
|
11632
12024
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -11636,11 +12028,11 @@ scripts?: Record<string, string> | undefined;
|
|
|
11636
12028
|
slug: string;
|
|
11637
12029
|
commitSha: string;
|
|
11638
12030
|
packageInfo: {
|
|
11639
|
-
packageInfo: {
|
|
11640
12031
|
description?: string | undefined;
|
|
12032
|
+
success?: boolean | undefined;
|
|
12033
|
+
error?: string | undefined;
|
|
11641
12034
|
name?: string | undefined;
|
|
11642
12035
|
version?: string | undefined;
|
|
11643
|
-
};
|
|
11644
12036
|
dependencies?: Record<string, string> | undefined;
|
|
11645
12037
|
devDependencies?: Record<string, string> | undefined;
|
|
11646
12038
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -11651,11 +12043,11 @@ targetPath?: string | undefined;
|
|
|
11651
12043
|
slug: string;
|
|
11652
12044
|
commitSha: string;
|
|
11653
12045
|
packageInfo: {
|
|
11654
|
-
packageInfo: {
|
|
11655
12046
|
description?: string | undefined;
|
|
12047
|
+
success?: boolean | undefined;
|
|
12048
|
+
error?: string | undefined;
|
|
11656
12049
|
name?: string | undefined;
|
|
11657
12050
|
version?: string | undefined;
|
|
11658
|
-
};
|
|
11659
12051
|
dependencies?: Record<string, string> | undefined;
|
|
11660
12052
|
devDependencies?: Record<string, string> | undefined;
|
|
11661
12053
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -11677,7 +12069,7 @@ message: string;
|
|
|
11677
12069
|
success: boolean;
|
|
11678
12070
|
applied: boolean;
|
|
11679
12071
|
error?: string | undefined;
|
|
11680
|
-
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"
|
|
12072
|
+
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"install", z.ZodObject<{
|
|
11681
12073
|
targetPath: z.ZodString;
|
|
11682
12074
|
}, "strip", z.ZodTypeAny, {
|
|
11683
12075
|
targetPath: string;
|
|
@@ -11685,27 +12077,24 @@ targetPath: string;
|
|
|
11685
12077
|
targetPath: string;
|
|
11686
12078
|
}>, z.ZodObject<{
|
|
11687
12079
|
success: z.ZodBoolean;
|
|
11688
|
-
|
|
11689
|
-
details: z.ZodOptional<z.ZodString>;
|
|
12080
|
+
error: z.ZodOptional<z.ZodString>;
|
|
11690
12081
|
}, "strip", z.ZodTypeAny, {
|
|
11691
|
-
message: string;
|
|
11692
12082
|
success: boolean;
|
|
11693
|
-
|
|
12083
|
+
error?: string | undefined;
|
|
11694
12084
|
}, {
|
|
11695
|
-
message: string;
|
|
11696
12085
|
success: boolean;
|
|
11697
|
-
|
|
12086
|
+
error?: string | undefined;
|
|
11698
12087
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"programmatic-file-copy", z.ZodObject<{
|
|
11699
12088
|
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
11700
|
-
kind: z.
|
|
12089
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
11701
12090
|
id: z.ZodString;
|
|
11702
12091
|
file: z.ZodString;
|
|
11703
12092
|
}, "strip", z.ZodTypeAny, {
|
|
11704
|
-
kind:
|
|
12093
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11705
12094
|
id: string;
|
|
11706
12095
|
file: string;
|
|
11707
12096
|
}, {
|
|
11708
|
-
kind:
|
|
12097
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11709
12098
|
id: string;
|
|
11710
12099
|
file: string;
|
|
11711
12100
|
}>, "many">;
|
|
@@ -11718,7 +12107,7 @@ slug: string;
|
|
|
11718
12107
|
commitSha: string;
|
|
11719
12108
|
templateDir: string;
|
|
11720
12109
|
orderedUnits: {
|
|
11721
|
-
kind:
|
|
12110
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11722
12111
|
id: string;
|
|
11723
12112
|
file: string;
|
|
11724
12113
|
}[];
|
|
@@ -11728,7 +12117,7 @@ slug: string;
|
|
|
11728
12117
|
commitSha: string;
|
|
11729
12118
|
templateDir: string;
|
|
11730
12119
|
orderedUnits: {
|
|
11731
|
-
kind:
|
|
12120
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11732
12121
|
id: string;
|
|
11733
12122
|
file: string;
|
|
11734
12123
|
}[];
|
|
@@ -11739,39 +12128,39 @@ copiedFiles: z.ZodArray<z.ZodObject<{
|
|
|
11739
12128
|
source: z.ZodString;
|
|
11740
12129
|
destination: z.ZodString;
|
|
11741
12130
|
unit: z.ZodObject<{
|
|
11742
|
-
kind: z.
|
|
12131
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
11743
12132
|
id: z.ZodString;
|
|
11744
12133
|
}, "strip", z.ZodTypeAny, {
|
|
11745
|
-
kind:
|
|
12134
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11746
12135
|
id: string;
|
|
11747
12136
|
}, {
|
|
11748
|
-
kind:
|
|
12137
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11749
12138
|
id: string;
|
|
11750
12139
|
}>;
|
|
11751
12140
|
}, "strip", z.ZodTypeAny, {
|
|
11752
12141
|
source: string;
|
|
11753
12142
|
destination: string;
|
|
11754
12143
|
unit: {
|
|
11755
|
-
kind:
|
|
12144
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11756
12145
|
id: string;
|
|
11757
12146
|
};
|
|
11758
12147
|
}, {
|
|
11759
12148
|
source: string;
|
|
11760
12149
|
destination: string;
|
|
11761
12150
|
unit: {
|
|
11762
|
-
kind:
|
|
12151
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11763
12152
|
id: string;
|
|
11764
12153
|
};
|
|
11765
12154
|
}>, "many">;
|
|
11766
12155
|
conflicts: z.ZodArray<z.ZodObject<{
|
|
11767
12156
|
unit: z.ZodObject<{
|
|
11768
|
-
kind: z.
|
|
12157
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
11769
12158
|
id: z.ZodString;
|
|
11770
12159
|
}, "strip", z.ZodTypeAny, {
|
|
11771
|
-
kind:
|
|
12160
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11772
12161
|
id: string;
|
|
11773
12162
|
}, {
|
|
11774
|
-
kind:
|
|
12163
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11775
12164
|
id: string;
|
|
11776
12165
|
}>;
|
|
11777
12166
|
issue: z.ZodString;
|
|
@@ -11779,7 +12168,7 @@ sourceFile: z.ZodString;
|
|
|
11779
12168
|
targetFile: z.ZodString;
|
|
11780
12169
|
}, "strip", z.ZodTypeAny, {
|
|
11781
12170
|
unit: {
|
|
11782
|
-
kind:
|
|
12171
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11783
12172
|
id: string;
|
|
11784
12173
|
};
|
|
11785
12174
|
issue: string;
|
|
@@ -11787,7 +12176,7 @@ sourceFile: string;
|
|
|
11787
12176
|
targetFile: string;
|
|
11788
12177
|
}, {
|
|
11789
12178
|
unit: {
|
|
11790
|
-
kind:
|
|
12179
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11791
12180
|
id: string;
|
|
11792
12181
|
};
|
|
11793
12182
|
issue: string;
|
|
@@ -11803,13 +12192,13 @@ copiedFiles: {
|
|
|
11803
12192
|
source: string;
|
|
11804
12193
|
destination: string;
|
|
11805
12194
|
unit: {
|
|
11806
|
-
kind:
|
|
12195
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11807
12196
|
id: string;
|
|
11808
12197
|
};
|
|
11809
12198
|
}[];
|
|
11810
12199
|
conflicts: {
|
|
11811
12200
|
unit: {
|
|
11812
|
-
kind:
|
|
12201
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11813
12202
|
id: string;
|
|
11814
12203
|
};
|
|
11815
12204
|
issue: string;
|
|
@@ -11824,13 +12213,13 @@ copiedFiles: {
|
|
|
11824
12213
|
source: string;
|
|
11825
12214
|
destination: string;
|
|
11826
12215
|
unit: {
|
|
11827
|
-
kind:
|
|
12216
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11828
12217
|
id: string;
|
|
11829
12218
|
};
|
|
11830
12219
|
}[];
|
|
11831
12220
|
conflicts: {
|
|
11832
12221
|
unit: {
|
|
11833
|
-
kind:
|
|
12222
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11834
12223
|
id: string;
|
|
11835
12224
|
};
|
|
11836
12225
|
issue: string;
|
|
@@ -11841,13 +12230,13 @@ error?: string | undefined;
|
|
|
11841
12230
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"intelligent-merge", z.ZodObject<{
|
|
11842
12231
|
conflicts: z.ZodArray<z.ZodObject<{
|
|
11843
12232
|
unit: z.ZodObject<{
|
|
11844
|
-
kind: z.
|
|
12233
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
11845
12234
|
id: z.ZodString;
|
|
11846
12235
|
}, "strip", z.ZodTypeAny, {
|
|
11847
|
-
kind:
|
|
12236
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11848
12237
|
id: string;
|
|
11849
12238
|
}, {
|
|
11850
|
-
kind:
|
|
12239
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11851
12240
|
id: string;
|
|
11852
12241
|
}>;
|
|
11853
12242
|
issue: z.ZodString;
|
|
@@ -11855,7 +12244,7 @@ sourceFile: z.ZodString;
|
|
|
11855
12244
|
targetFile: z.ZodString;
|
|
11856
12245
|
}, "strip", z.ZodTypeAny, {
|
|
11857
12246
|
unit: {
|
|
11858
|
-
kind:
|
|
12247
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11859
12248
|
id: string;
|
|
11860
12249
|
};
|
|
11861
12250
|
issue: string;
|
|
@@ -11863,7 +12252,7 @@ sourceFile: string;
|
|
|
11863
12252
|
targetFile: string;
|
|
11864
12253
|
}, {
|
|
11865
12254
|
unit: {
|
|
11866
|
-
kind:
|
|
12255
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11867
12256
|
id: string;
|
|
11868
12257
|
};
|
|
11869
12258
|
issue: string;
|
|
@@ -11874,27 +12263,27 @@ copiedFiles: z.ZodArray<z.ZodObject<{
|
|
|
11874
12263
|
source: z.ZodString;
|
|
11875
12264
|
destination: z.ZodString;
|
|
11876
12265
|
unit: z.ZodObject<{
|
|
11877
|
-
kind: z.
|
|
12266
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
11878
12267
|
id: z.ZodString;
|
|
11879
12268
|
}, "strip", z.ZodTypeAny, {
|
|
11880
|
-
kind:
|
|
12269
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11881
12270
|
id: string;
|
|
11882
12271
|
}, {
|
|
11883
|
-
kind:
|
|
12272
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11884
12273
|
id: string;
|
|
11885
12274
|
}>;
|
|
11886
12275
|
}, "strip", z.ZodTypeAny, {
|
|
11887
12276
|
source: string;
|
|
11888
12277
|
destination: string;
|
|
11889
12278
|
unit: {
|
|
11890
|
-
kind:
|
|
12279
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11891
12280
|
id: string;
|
|
11892
12281
|
};
|
|
11893
12282
|
}, {
|
|
11894
12283
|
source: string;
|
|
11895
12284
|
destination: string;
|
|
11896
12285
|
unit: {
|
|
11897
|
-
kind:
|
|
12286
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11898
12287
|
id: string;
|
|
11899
12288
|
};
|
|
11900
12289
|
}>, "many">;
|
|
@@ -11902,6 +12291,7 @@ templateDir: z.ZodString;
|
|
|
11902
12291
|
commitSha: z.ZodString;
|
|
11903
12292
|
slug: z.ZodString;
|
|
11904
12293
|
targetPath: z.ZodOptional<z.ZodString>;
|
|
12294
|
+
branchName: z.ZodOptional<z.ZodString>;
|
|
11905
12295
|
}, "strip", z.ZodTypeAny, {
|
|
11906
12296
|
slug: string;
|
|
11907
12297
|
commitSha: string;
|
|
@@ -11910,13 +12300,13 @@ copiedFiles: {
|
|
|
11910
12300
|
source: string;
|
|
11911
12301
|
destination: string;
|
|
11912
12302
|
unit: {
|
|
11913
|
-
kind:
|
|
12303
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11914
12304
|
id: string;
|
|
11915
12305
|
};
|
|
11916
12306
|
}[];
|
|
11917
12307
|
conflicts: {
|
|
11918
12308
|
unit: {
|
|
11919
|
-
kind:
|
|
12309
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11920
12310
|
id: string;
|
|
11921
12311
|
};
|
|
11922
12312
|
issue: string;
|
|
@@ -11924,6 +12314,7 @@ sourceFile: string;
|
|
|
11924
12314
|
targetFile: string;
|
|
11925
12315
|
}[];
|
|
11926
12316
|
targetPath?: string | undefined;
|
|
12317
|
+
branchName?: string | undefined;
|
|
11927
12318
|
}, {
|
|
11928
12319
|
slug: string;
|
|
11929
12320
|
commitSha: string;
|
|
@@ -11932,13 +12323,13 @@ copiedFiles: {
|
|
|
11932
12323
|
source: string;
|
|
11933
12324
|
destination: string;
|
|
11934
12325
|
unit: {
|
|
11935
|
-
kind:
|
|
12326
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11936
12327
|
id: string;
|
|
11937
12328
|
};
|
|
11938
12329
|
}[];
|
|
11939
12330
|
conflicts: {
|
|
11940
12331
|
unit: {
|
|
11941
|
-
kind:
|
|
12332
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11942
12333
|
id: string;
|
|
11943
12334
|
};
|
|
11944
12335
|
issue: string;
|
|
@@ -11946,53 +12337,52 @@ sourceFile: string;
|
|
|
11946
12337
|
targetFile: string;
|
|
11947
12338
|
}[];
|
|
11948
12339
|
targetPath?: string | undefined;
|
|
12340
|
+
branchName?: string | undefined;
|
|
11949
12341
|
}>, z.ZodObject<{
|
|
11950
12342
|
success: z.ZodBoolean;
|
|
11951
12343
|
applied: z.ZodBoolean;
|
|
11952
12344
|
message: z.ZodString;
|
|
11953
12345
|
conflictsResolved: z.ZodArray<z.ZodObject<{
|
|
11954
12346
|
unit: z.ZodObject<{
|
|
11955
|
-
kind: z.
|
|
12347
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
11956
12348
|
id: z.ZodString;
|
|
11957
12349
|
}, "strip", z.ZodTypeAny, {
|
|
11958
|
-
kind:
|
|
12350
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11959
12351
|
id: string;
|
|
11960
12352
|
}, {
|
|
11961
|
-
kind:
|
|
12353
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11962
12354
|
id: string;
|
|
11963
12355
|
}>;
|
|
11964
12356
|
issue: z.ZodString;
|
|
11965
12357
|
resolution: z.ZodString;
|
|
11966
12358
|
}, "strip", z.ZodTypeAny, {
|
|
11967
12359
|
unit: {
|
|
11968
|
-
kind:
|
|
12360
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11969
12361
|
id: string;
|
|
11970
12362
|
};
|
|
11971
12363
|
issue: string;
|
|
11972
12364
|
resolution: string;
|
|
11973
12365
|
}, {
|
|
11974
12366
|
unit: {
|
|
11975
|
-
kind:
|
|
12367
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11976
12368
|
id: string;
|
|
11977
12369
|
};
|
|
11978
12370
|
issue: string;
|
|
11979
12371
|
resolution: string;
|
|
11980
12372
|
}>, "many">;
|
|
11981
12373
|
error: z.ZodOptional<z.ZodString>;
|
|
11982
|
-
branchName: z.ZodOptional<z.ZodString>;
|
|
11983
12374
|
}, "strip", z.ZodTypeAny, {
|
|
11984
12375
|
message: string;
|
|
11985
12376
|
success: boolean;
|
|
11986
12377
|
applied: boolean;
|
|
11987
12378
|
conflictsResolved: {
|
|
11988
12379
|
unit: {
|
|
11989
|
-
kind:
|
|
12380
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
11990
12381
|
id: string;
|
|
11991
12382
|
};
|
|
11992
12383
|
issue: string;
|
|
11993
12384
|
resolution: string;
|
|
11994
12385
|
}[];
|
|
11995
|
-
branchName?: string | undefined;
|
|
11996
12386
|
error?: string | undefined;
|
|
11997
12387
|
}, {
|
|
11998
12388
|
message: string;
|
|
@@ -12000,13 +12390,12 @@ success: boolean;
|
|
|
12000
12390
|
applied: boolean;
|
|
12001
12391
|
conflictsResolved: {
|
|
12002
12392
|
unit: {
|
|
12003
|
-
kind:
|
|
12393
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12004
12394
|
id: string;
|
|
12005
12395
|
};
|
|
12006
12396
|
issue: string;
|
|
12007
12397
|
resolution: string;
|
|
12008
12398
|
}[];
|
|
12009
|
-
branchName?: string | undefined;
|
|
12010
12399
|
error?: string | undefined;
|
|
12011
12400
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"validation-and-fix", z.ZodObject<{
|
|
12012
12401
|
commitSha: z.ZodString;
|
|
@@ -12014,15 +12403,15 @@ slug: z.ZodString;
|
|
|
12014
12403
|
targetPath: z.ZodOptional<z.ZodString>;
|
|
12015
12404
|
templateDir: z.ZodString;
|
|
12016
12405
|
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
12017
|
-
kind: z.
|
|
12406
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12018
12407
|
id: z.ZodString;
|
|
12019
12408
|
file: z.ZodString;
|
|
12020
12409
|
}, "strip", z.ZodTypeAny, {
|
|
12021
|
-
kind:
|
|
12410
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12022
12411
|
id: string;
|
|
12023
12412
|
file: string;
|
|
12024
12413
|
}, {
|
|
12025
|
-
kind:
|
|
12414
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12026
12415
|
id: string;
|
|
12027
12416
|
file: string;
|
|
12028
12417
|
}>, "many">;
|
|
@@ -12030,53 +12419,53 @@ copiedFiles: z.ZodArray<z.ZodObject<{
|
|
|
12030
12419
|
source: z.ZodString;
|
|
12031
12420
|
destination: z.ZodString;
|
|
12032
12421
|
unit: z.ZodObject<{
|
|
12033
|
-
kind: z.
|
|
12422
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12034
12423
|
id: z.ZodString;
|
|
12035
12424
|
}, "strip", z.ZodTypeAny, {
|
|
12036
|
-
kind:
|
|
12425
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12037
12426
|
id: string;
|
|
12038
12427
|
}, {
|
|
12039
|
-
kind:
|
|
12428
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12040
12429
|
id: string;
|
|
12041
12430
|
}>;
|
|
12042
12431
|
}, "strip", z.ZodTypeAny, {
|
|
12043
12432
|
source: string;
|
|
12044
12433
|
destination: string;
|
|
12045
12434
|
unit: {
|
|
12046
|
-
kind:
|
|
12435
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12047
12436
|
id: string;
|
|
12048
12437
|
};
|
|
12049
12438
|
}, {
|
|
12050
12439
|
source: string;
|
|
12051
12440
|
destination: string;
|
|
12052
12441
|
unit: {
|
|
12053
|
-
kind:
|
|
12442
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12054
12443
|
id: string;
|
|
12055
12444
|
};
|
|
12056
12445
|
}>, "many">;
|
|
12057
12446
|
conflictsResolved: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
12058
12447
|
unit: z.ZodObject<{
|
|
12059
|
-
kind: z.
|
|
12448
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12060
12449
|
id: z.ZodString;
|
|
12061
12450
|
}, "strip", z.ZodTypeAny, {
|
|
12062
|
-
kind:
|
|
12451
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12063
12452
|
id: string;
|
|
12064
12453
|
}, {
|
|
12065
|
-
kind:
|
|
12454
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12066
12455
|
id: string;
|
|
12067
12456
|
}>;
|
|
12068
12457
|
issue: z.ZodString;
|
|
12069
12458
|
resolution: z.ZodString;
|
|
12070
12459
|
}, "strip", z.ZodTypeAny, {
|
|
12071
12460
|
unit: {
|
|
12072
|
-
kind:
|
|
12461
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12073
12462
|
id: string;
|
|
12074
12463
|
};
|
|
12075
12464
|
issue: string;
|
|
12076
12465
|
resolution: string;
|
|
12077
12466
|
}, {
|
|
12078
12467
|
unit: {
|
|
12079
|
-
kind:
|
|
12468
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12080
12469
|
id: string;
|
|
12081
12470
|
};
|
|
12082
12471
|
issue: string;
|
|
@@ -12088,7 +12477,7 @@ slug: string;
|
|
|
12088
12477
|
commitSha: string;
|
|
12089
12478
|
templateDir: string;
|
|
12090
12479
|
orderedUnits: {
|
|
12091
|
-
kind:
|
|
12480
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12092
12481
|
id: string;
|
|
12093
12482
|
file: string;
|
|
12094
12483
|
}[];
|
|
@@ -12096,7 +12485,7 @@ copiedFiles: {
|
|
|
12096
12485
|
source: string;
|
|
12097
12486
|
destination: string;
|
|
12098
12487
|
unit: {
|
|
12099
|
-
kind:
|
|
12488
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12100
12489
|
id: string;
|
|
12101
12490
|
};
|
|
12102
12491
|
}[];
|
|
@@ -12104,7 +12493,7 @@ maxIterations: number;
|
|
|
12104
12493
|
targetPath?: string | undefined;
|
|
12105
12494
|
conflictsResolved?: {
|
|
12106
12495
|
unit: {
|
|
12107
|
-
kind:
|
|
12496
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12108
12497
|
id: string;
|
|
12109
12498
|
};
|
|
12110
12499
|
issue: string;
|
|
@@ -12115,7 +12504,7 @@ slug: string;
|
|
|
12115
12504
|
commitSha: string;
|
|
12116
12505
|
templateDir: string;
|
|
12117
12506
|
orderedUnits: {
|
|
12118
|
-
kind:
|
|
12507
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12119
12508
|
id: string;
|
|
12120
12509
|
file: string;
|
|
12121
12510
|
}[];
|
|
@@ -12123,14 +12512,14 @@ copiedFiles: {
|
|
|
12123
12512
|
source: string;
|
|
12124
12513
|
destination: string;
|
|
12125
12514
|
unit: {
|
|
12126
|
-
kind:
|
|
12515
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12127
12516
|
id: string;
|
|
12128
12517
|
};
|
|
12129
12518
|
}[];
|
|
12130
12519
|
targetPath?: string | undefined;
|
|
12131
12520
|
conflictsResolved?: {
|
|
12132
12521
|
unit: {
|
|
12133
|
-
kind:
|
|
12522
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12134
12523
|
id: string;
|
|
12135
12524
|
};
|
|
12136
12525
|
issue: string;
|
|
@@ -12175,9 +12564,7 @@ errorsFixed: number;
|
|
|
12175
12564
|
remainingErrors: number;
|
|
12176
12565
|
};
|
|
12177
12566
|
error?: string | undefined;
|
|
12178
|
-
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType>)[]
|
|
12179
|
-
|
|
12180
|
-
export declare const mergeTemplateWorkflow: Workflow<DefaultEngineType, (Step<"clone-template", z.ZodObject<{
|
|
12567
|
+
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType>)[], "agent-builder-template", z.ZodObject<{
|
|
12181
12568
|
repo: z.ZodString;
|
|
12182
12569
|
ref: z.ZodOptional<z.ZodString>;
|
|
12183
12570
|
slug: z.ZodOptional<z.ZodString>;
|
|
@@ -12193,63 +12580,1160 @@ slug?: string | undefined;
|
|
|
12193
12580
|
ref?: string | undefined;
|
|
12194
12581
|
targetPath?: string | undefined;
|
|
12195
12582
|
}>, z.ZodObject<{
|
|
12196
|
-
|
|
12197
|
-
|
|
12198
|
-
|
|
12583
|
+
success: z.ZodBoolean;
|
|
12584
|
+
applied: z.ZodBoolean;
|
|
12585
|
+
branchName: z.ZodOptional<z.ZodString>;
|
|
12586
|
+
message: z.ZodString;
|
|
12587
|
+
validationResults: z.ZodOptional<z.ZodObject<{
|
|
12588
|
+
valid: z.ZodBoolean;
|
|
12589
|
+
errorsFixed: z.ZodNumber;
|
|
12590
|
+
remainingErrors: z.ZodNumber;
|
|
12199
12591
|
}, "strip", z.ZodTypeAny, {
|
|
12200
|
-
|
|
12201
|
-
|
|
12202
|
-
|
|
12592
|
+
valid: boolean;
|
|
12593
|
+
errorsFixed: number;
|
|
12594
|
+
remainingErrors: number;
|
|
12203
12595
|
}, {
|
|
12204
|
-
|
|
12205
|
-
|
|
12206
|
-
|
|
12207
|
-
}
|
|
12208
|
-
|
|
12209
|
-
|
|
12210
|
-
|
|
12596
|
+
valid: boolean;
|
|
12597
|
+
errorsFixed: number;
|
|
12598
|
+
remainingErrors: number;
|
|
12599
|
+
}>>;
|
|
12600
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12601
|
+
errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
12602
|
+
stepResults: z.ZodOptional<z.ZodObject<{
|
|
12603
|
+
cloneSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12604
|
+
analyzeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12605
|
+
discoverSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12606
|
+
orderSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12607
|
+
prepareBranchSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12608
|
+
packageMergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12609
|
+
installSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12610
|
+
copySuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12611
|
+
mergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12612
|
+
validationSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12613
|
+
filesCopied: z.ZodNumber;
|
|
12614
|
+
conflictsSkipped: z.ZodNumber;
|
|
12615
|
+
conflictsResolved: z.ZodNumber;
|
|
12211
12616
|
}, "strip", z.ZodTypeAny, {
|
|
12212
|
-
|
|
12213
|
-
|
|
12214
|
-
|
|
12617
|
+
conflictsResolved: number;
|
|
12618
|
+
filesCopied: number;
|
|
12619
|
+
conflictsSkipped: number;
|
|
12620
|
+
cloneSuccess?: boolean | undefined;
|
|
12621
|
+
analyzeSuccess?: boolean | undefined;
|
|
12622
|
+
discoverSuccess?: boolean | undefined;
|
|
12623
|
+
orderSuccess?: boolean | undefined;
|
|
12624
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12625
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12626
|
+
installSuccess?: boolean | undefined;
|
|
12627
|
+
copySuccess?: boolean | undefined;
|
|
12628
|
+
mergeSuccess?: boolean | undefined;
|
|
12629
|
+
validationSuccess?: boolean | undefined;
|
|
12215
12630
|
}, {
|
|
12216
|
-
|
|
12217
|
-
|
|
12218
|
-
|
|
12631
|
+
conflictsResolved: number;
|
|
12632
|
+
filesCopied: number;
|
|
12633
|
+
conflictsSkipped: number;
|
|
12634
|
+
cloneSuccess?: boolean | undefined;
|
|
12635
|
+
analyzeSuccess?: boolean | undefined;
|
|
12636
|
+
discoverSuccess?: boolean | undefined;
|
|
12637
|
+
orderSuccess?: boolean | undefined;
|
|
12638
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12639
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12640
|
+
installSuccess?: boolean | undefined;
|
|
12641
|
+
copySuccess?: boolean | undefined;
|
|
12642
|
+
mergeSuccess?: boolean | undefined;
|
|
12643
|
+
validationSuccess?: boolean | undefined;
|
|
12644
|
+
}>>;
|
|
12645
|
+
}, "strip", z.ZodTypeAny, {
|
|
12646
|
+
message: string;
|
|
12647
|
+
success: boolean;
|
|
12648
|
+
applied: boolean;
|
|
12649
|
+
error?: string | undefined;
|
|
12650
|
+
branchName?: string | undefined;
|
|
12651
|
+
validationResults?: {
|
|
12652
|
+
valid: boolean;
|
|
12653
|
+
errorsFixed: number;
|
|
12654
|
+
remainingErrors: number;
|
|
12655
|
+
} | undefined;
|
|
12656
|
+
errors?: string[] | undefined;
|
|
12657
|
+
stepResults?: {
|
|
12658
|
+
conflictsResolved: number;
|
|
12659
|
+
filesCopied: number;
|
|
12660
|
+
conflictsSkipped: number;
|
|
12661
|
+
cloneSuccess?: boolean | undefined;
|
|
12662
|
+
analyzeSuccess?: boolean | undefined;
|
|
12663
|
+
discoverSuccess?: boolean | undefined;
|
|
12664
|
+
orderSuccess?: boolean | undefined;
|
|
12665
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12666
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12667
|
+
installSuccess?: boolean | undefined;
|
|
12668
|
+
copySuccess?: boolean | undefined;
|
|
12669
|
+
mergeSuccess?: boolean | undefined;
|
|
12670
|
+
validationSuccess?: boolean | undefined;
|
|
12671
|
+
} | undefined;
|
|
12672
|
+
}, {
|
|
12673
|
+
message: string;
|
|
12674
|
+
success: boolean;
|
|
12675
|
+
applied: boolean;
|
|
12676
|
+
error?: string | undefined;
|
|
12677
|
+
branchName?: string | undefined;
|
|
12678
|
+
validationResults?: {
|
|
12679
|
+
valid: boolean;
|
|
12680
|
+
errorsFixed: number;
|
|
12681
|
+
remainingErrors: number;
|
|
12682
|
+
} | undefined;
|
|
12683
|
+
errors?: string[] | undefined;
|
|
12684
|
+
stepResults?: {
|
|
12685
|
+
conflictsResolved: number;
|
|
12686
|
+
filesCopied: number;
|
|
12687
|
+
conflictsSkipped: number;
|
|
12688
|
+
cloneSuccess?: boolean | undefined;
|
|
12689
|
+
analyzeSuccess?: boolean | undefined;
|
|
12690
|
+
discoverSuccess?: boolean | undefined;
|
|
12691
|
+
orderSuccess?: boolean | undefined;
|
|
12692
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12693
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12694
|
+
installSuccess?: boolean | undefined;
|
|
12695
|
+
copySuccess?: boolean | undefined;
|
|
12696
|
+
mergeSuccess?: boolean | undefined;
|
|
12697
|
+
validationSuccess?: boolean | undefined;
|
|
12698
|
+
} | undefined;
|
|
12219
12699
|
}>, z.ZodObject<{
|
|
12220
|
-
|
|
12221
|
-
|
|
12222
|
-
|
|
12223
|
-
|
|
12224
|
-
|
|
12225
|
-
|
|
12226
|
-
|
|
12227
|
-
|
|
12700
|
+
success: z.ZodBoolean;
|
|
12701
|
+
applied: z.ZodBoolean;
|
|
12702
|
+
branchName: z.ZodOptional<z.ZodString>;
|
|
12703
|
+
message: z.ZodString;
|
|
12704
|
+
validationResults: z.ZodOptional<z.ZodObject<{
|
|
12705
|
+
valid: z.ZodBoolean;
|
|
12706
|
+
errorsFixed: z.ZodNumber;
|
|
12707
|
+
remainingErrors: z.ZodNumber;
|
|
12228
12708
|
}, "strip", z.ZodTypeAny, {
|
|
12229
|
-
|
|
12230
|
-
|
|
12231
|
-
|
|
12709
|
+
valid: boolean;
|
|
12710
|
+
errorsFixed: number;
|
|
12711
|
+
remainingErrors: number;
|
|
12232
12712
|
}, {
|
|
12233
|
-
|
|
12234
|
-
|
|
12235
|
-
|
|
12236
|
-
}
|
|
12713
|
+
valid: boolean;
|
|
12714
|
+
errorsFixed: number;
|
|
12715
|
+
remainingErrors: number;
|
|
12716
|
+
}>>;
|
|
12717
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12718
|
+
errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
12719
|
+
stepResults: z.ZodOptional<z.ZodObject<{
|
|
12720
|
+
cloneSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12721
|
+
analyzeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12722
|
+
discoverSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12723
|
+
orderSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12724
|
+
prepareBranchSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12725
|
+
packageMergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12726
|
+
installSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12727
|
+
copySuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12728
|
+
mergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12729
|
+
validationSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12730
|
+
filesCopied: z.ZodNumber;
|
|
12731
|
+
conflictsSkipped: z.ZodNumber;
|
|
12732
|
+
conflictsResolved: z.ZodNumber;
|
|
12237
12733
|
}, "strip", z.ZodTypeAny, {
|
|
12238
|
-
|
|
12239
|
-
|
|
12240
|
-
|
|
12241
|
-
|
|
12242
|
-
|
|
12243
|
-
|
|
12244
|
-
|
|
12245
|
-
|
|
12246
|
-
|
|
12734
|
+
conflictsResolved: number;
|
|
12735
|
+
filesCopied: number;
|
|
12736
|
+
conflictsSkipped: number;
|
|
12737
|
+
cloneSuccess?: boolean | undefined;
|
|
12738
|
+
analyzeSuccess?: boolean | undefined;
|
|
12739
|
+
discoverSuccess?: boolean | undefined;
|
|
12740
|
+
orderSuccess?: boolean | undefined;
|
|
12741
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12742
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12743
|
+
installSuccess?: boolean | undefined;
|
|
12744
|
+
copySuccess?: boolean | undefined;
|
|
12745
|
+
mergeSuccess?: boolean | undefined;
|
|
12746
|
+
validationSuccess?: boolean | undefined;
|
|
12247
12747
|
}, {
|
|
12248
|
-
|
|
12249
|
-
|
|
12250
|
-
|
|
12251
|
-
|
|
12252
|
-
|
|
12748
|
+
conflictsResolved: number;
|
|
12749
|
+
filesCopied: number;
|
|
12750
|
+
conflictsSkipped: number;
|
|
12751
|
+
cloneSuccess?: boolean | undefined;
|
|
12752
|
+
analyzeSuccess?: boolean | undefined;
|
|
12753
|
+
discoverSuccess?: boolean | undefined;
|
|
12754
|
+
orderSuccess?: boolean | undefined;
|
|
12755
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12756
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12757
|
+
installSuccess?: boolean | undefined;
|
|
12758
|
+
copySuccess?: boolean | undefined;
|
|
12759
|
+
mergeSuccess?: boolean | undefined;
|
|
12760
|
+
validationSuccess?: boolean | undefined;
|
|
12761
|
+
}>>;
|
|
12762
|
+
}, "strip", z.ZodTypeAny, {
|
|
12763
|
+
message: string;
|
|
12764
|
+
success: boolean;
|
|
12765
|
+
applied: boolean;
|
|
12766
|
+
error?: string | undefined;
|
|
12767
|
+
branchName?: string | undefined;
|
|
12768
|
+
validationResults?: {
|
|
12769
|
+
valid: boolean;
|
|
12770
|
+
errorsFixed: number;
|
|
12771
|
+
remainingErrors: number;
|
|
12772
|
+
} | undefined;
|
|
12773
|
+
errors?: string[] | undefined;
|
|
12774
|
+
stepResults?: {
|
|
12775
|
+
conflictsResolved: number;
|
|
12776
|
+
filesCopied: number;
|
|
12777
|
+
conflictsSkipped: number;
|
|
12778
|
+
cloneSuccess?: boolean | undefined;
|
|
12779
|
+
analyzeSuccess?: boolean | undefined;
|
|
12780
|
+
discoverSuccess?: boolean | undefined;
|
|
12781
|
+
orderSuccess?: boolean | undefined;
|
|
12782
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12783
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12784
|
+
installSuccess?: boolean | undefined;
|
|
12785
|
+
copySuccess?: boolean | undefined;
|
|
12786
|
+
mergeSuccess?: boolean | undefined;
|
|
12787
|
+
validationSuccess?: boolean | undefined;
|
|
12788
|
+
} | undefined;
|
|
12789
|
+
}, {
|
|
12790
|
+
message: string;
|
|
12791
|
+
success: boolean;
|
|
12792
|
+
applied: boolean;
|
|
12793
|
+
error?: string | undefined;
|
|
12794
|
+
branchName?: string | undefined;
|
|
12795
|
+
validationResults?: {
|
|
12796
|
+
valid: boolean;
|
|
12797
|
+
errorsFixed: number;
|
|
12798
|
+
remainingErrors: number;
|
|
12799
|
+
} | undefined;
|
|
12800
|
+
errors?: string[] | undefined;
|
|
12801
|
+
stepResults?: {
|
|
12802
|
+
conflictsResolved: number;
|
|
12803
|
+
filesCopied: number;
|
|
12804
|
+
conflictsSkipped: number;
|
|
12805
|
+
cloneSuccess?: boolean | undefined;
|
|
12806
|
+
analyzeSuccess?: boolean | undefined;
|
|
12807
|
+
discoverSuccess?: boolean | undefined;
|
|
12808
|
+
orderSuccess?: boolean | undefined;
|
|
12809
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12810
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12811
|
+
installSuccess?: boolean | undefined;
|
|
12812
|
+
copySuccess?: boolean | undefined;
|
|
12813
|
+
mergeSuccess?: boolean | undefined;
|
|
12814
|
+
validationSuccess?: boolean | undefined;
|
|
12815
|
+
} | undefined;
|
|
12816
|
+
}>>;
|
|
12817
|
+
export { agentBuilderTemplateWorkflow }
|
|
12818
|
+
export { agentBuilderTemplateWorkflow as agentBuilderTemplateWorkflow_alias_1 }
|
|
12819
|
+
export { agentBuilderTemplateWorkflow as agentBuilderTemplateWorkflow_alias_2 }
|
|
12820
|
+
|
|
12821
|
+
export declare const ApplyResultSchema: z.ZodObject<{
|
|
12822
|
+
success: z.ZodBoolean;
|
|
12823
|
+
applied: z.ZodBoolean;
|
|
12824
|
+
branchName: z.ZodOptional<z.ZodString>;
|
|
12825
|
+
message: z.ZodString;
|
|
12826
|
+
validationResults: z.ZodOptional<z.ZodObject<{
|
|
12827
|
+
valid: z.ZodBoolean;
|
|
12828
|
+
errorsFixed: z.ZodNumber;
|
|
12829
|
+
remainingErrors: z.ZodNumber;
|
|
12830
|
+
}, "strip", z.ZodTypeAny, {
|
|
12831
|
+
valid: boolean;
|
|
12832
|
+
errorsFixed: number;
|
|
12833
|
+
remainingErrors: number;
|
|
12834
|
+
}, {
|
|
12835
|
+
valid: boolean;
|
|
12836
|
+
errorsFixed: number;
|
|
12837
|
+
remainingErrors: number;
|
|
12838
|
+
}>>;
|
|
12839
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12840
|
+
errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
12841
|
+
stepResults: z.ZodOptional<z.ZodObject<{
|
|
12842
|
+
cloneSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12843
|
+
analyzeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12844
|
+
discoverSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12845
|
+
orderSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12846
|
+
prepareBranchSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12847
|
+
packageMergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12848
|
+
installSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12849
|
+
copySuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12850
|
+
mergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12851
|
+
validationSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
12852
|
+
filesCopied: z.ZodNumber;
|
|
12853
|
+
conflictsSkipped: z.ZodNumber;
|
|
12854
|
+
conflictsResolved: z.ZodNumber;
|
|
12855
|
+
}, "strip", z.ZodTypeAny, {
|
|
12856
|
+
conflictsResolved: number;
|
|
12857
|
+
filesCopied: number;
|
|
12858
|
+
conflictsSkipped: number;
|
|
12859
|
+
cloneSuccess?: boolean | undefined;
|
|
12860
|
+
analyzeSuccess?: boolean | undefined;
|
|
12861
|
+
discoverSuccess?: boolean | undefined;
|
|
12862
|
+
orderSuccess?: boolean | undefined;
|
|
12863
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12864
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12865
|
+
installSuccess?: boolean | undefined;
|
|
12866
|
+
copySuccess?: boolean | undefined;
|
|
12867
|
+
mergeSuccess?: boolean | undefined;
|
|
12868
|
+
validationSuccess?: boolean | undefined;
|
|
12869
|
+
}, {
|
|
12870
|
+
conflictsResolved: number;
|
|
12871
|
+
filesCopied: number;
|
|
12872
|
+
conflictsSkipped: number;
|
|
12873
|
+
cloneSuccess?: boolean | undefined;
|
|
12874
|
+
analyzeSuccess?: boolean | undefined;
|
|
12875
|
+
discoverSuccess?: boolean | undefined;
|
|
12876
|
+
orderSuccess?: boolean | undefined;
|
|
12877
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12878
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12879
|
+
installSuccess?: boolean | undefined;
|
|
12880
|
+
copySuccess?: boolean | undefined;
|
|
12881
|
+
mergeSuccess?: boolean | undefined;
|
|
12882
|
+
validationSuccess?: boolean | undefined;
|
|
12883
|
+
}>>;
|
|
12884
|
+
}, "strip", z.ZodTypeAny, {
|
|
12885
|
+
message: string;
|
|
12886
|
+
success: boolean;
|
|
12887
|
+
applied: boolean;
|
|
12888
|
+
error?: string | undefined;
|
|
12889
|
+
branchName?: string | undefined;
|
|
12890
|
+
validationResults?: {
|
|
12891
|
+
valid: boolean;
|
|
12892
|
+
errorsFixed: number;
|
|
12893
|
+
remainingErrors: number;
|
|
12894
|
+
} | undefined;
|
|
12895
|
+
errors?: string[] | undefined;
|
|
12896
|
+
stepResults?: {
|
|
12897
|
+
conflictsResolved: number;
|
|
12898
|
+
filesCopied: number;
|
|
12899
|
+
conflictsSkipped: number;
|
|
12900
|
+
cloneSuccess?: boolean | undefined;
|
|
12901
|
+
analyzeSuccess?: boolean | undefined;
|
|
12902
|
+
discoverSuccess?: boolean | undefined;
|
|
12903
|
+
orderSuccess?: boolean | undefined;
|
|
12904
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12905
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12906
|
+
installSuccess?: boolean | undefined;
|
|
12907
|
+
copySuccess?: boolean | undefined;
|
|
12908
|
+
mergeSuccess?: boolean | undefined;
|
|
12909
|
+
validationSuccess?: boolean | undefined;
|
|
12910
|
+
} | undefined;
|
|
12911
|
+
}, {
|
|
12912
|
+
message: string;
|
|
12913
|
+
success: boolean;
|
|
12914
|
+
applied: boolean;
|
|
12915
|
+
error?: string | undefined;
|
|
12916
|
+
branchName?: string | undefined;
|
|
12917
|
+
validationResults?: {
|
|
12918
|
+
valid: boolean;
|
|
12919
|
+
errorsFixed: number;
|
|
12920
|
+
remainingErrors: number;
|
|
12921
|
+
} | undefined;
|
|
12922
|
+
errors?: string[] | undefined;
|
|
12923
|
+
stepResults?: {
|
|
12924
|
+
conflictsResolved: number;
|
|
12925
|
+
filesCopied: number;
|
|
12926
|
+
conflictsSkipped: number;
|
|
12927
|
+
cloneSuccess?: boolean | undefined;
|
|
12928
|
+
analyzeSuccess?: boolean | undefined;
|
|
12929
|
+
discoverSuccess?: boolean | undefined;
|
|
12930
|
+
orderSuccess?: boolean | undefined;
|
|
12931
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
12932
|
+
packageMergeSuccess?: boolean | undefined;
|
|
12933
|
+
installSuccess?: boolean | undefined;
|
|
12934
|
+
copySuccess?: boolean | undefined;
|
|
12935
|
+
mergeSuccess?: boolean | undefined;
|
|
12936
|
+
validationSuccess?: boolean | undefined;
|
|
12937
|
+
} | undefined;
|
|
12938
|
+
}>;
|
|
12939
|
+
|
|
12940
|
+
export declare function backupAndReplaceFile(sourceFile: string, targetFile: string): Promise<void>;
|
|
12941
|
+
|
|
12942
|
+
export declare const CloneTemplateResultSchema: z.ZodObject<{
|
|
12943
|
+
templateDir: z.ZodString;
|
|
12944
|
+
commitSha: z.ZodString;
|
|
12945
|
+
slug: z.ZodString;
|
|
12946
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
12947
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12948
|
+
}, "strip", z.ZodTypeAny, {
|
|
12949
|
+
slug: string;
|
|
12950
|
+
commitSha: string;
|
|
12951
|
+
templateDir: string;
|
|
12952
|
+
success?: boolean | undefined;
|
|
12953
|
+
error?: string | undefined;
|
|
12954
|
+
}, {
|
|
12955
|
+
slug: string;
|
|
12956
|
+
commitSha: string;
|
|
12957
|
+
templateDir: string;
|
|
12958
|
+
success?: boolean | undefined;
|
|
12959
|
+
error?: string | undefined;
|
|
12960
|
+
}>;
|
|
12961
|
+
|
|
12962
|
+
export declare const ConflictResolutionSchema: z.ZodObject<{
|
|
12963
|
+
unit: z.ZodObject<{
|
|
12964
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12965
|
+
id: z.ZodString;
|
|
12966
|
+
}, "strip", z.ZodTypeAny, {
|
|
12967
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12968
|
+
id: string;
|
|
12969
|
+
}, {
|
|
12970
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12971
|
+
id: string;
|
|
12972
|
+
}>;
|
|
12973
|
+
issue: z.ZodString;
|
|
12974
|
+
resolution: z.ZodString;
|
|
12975
|
+
}, "strip", z.ZodTypeAny, {
|
|
12976
|
+
unit: {
|
|
12977
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12978
|
+
id: string;
|
|
12979
|
+
};
|
|
12980
|
+
issue: string;
|
|
12981
|
+
resolution: string;
|
|
12982
|
+
}, {
|
|
12983
|
+
unit: {
|
|
12984
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12985
|
+
id: string;
|
|
12986
|
+
};
|
|
12987
|
+
issue: string;
|
|
12988
|
+
resolution: string;
|
|
12989
|
+
}>;
|
|
12990
|
+
|
|
12991
|
+
export declare const ConflictSchema: z.ZodObject<{
|
|
12992
|
+
unit: z.ZodObject<{
|
|
12993
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12994
|
+
id: z.ZodString;
|
|
12995
|
+
}, "strip", z.ZodTypeAny, {
|
|
12996
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12997
|
+
id: string;
|
|
12998
|
+
}, {
|
|
12999
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13000
|
+
id: string;
|
|
13001
|
+
}>;
|
|
13002
|
+
issue: z.ZodString;
|
|
13003
|
+
sourceFile: z.ZodString;
|
|
13004
|
+
targetFile: z.ZodString;
|
|
13005
|
+
}, "strip", z.ZodTypeAny, {
|
|
13006
|
+
unit: {
|
|
13007
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13008
|
+
id: string;
|
|
13009
|
+
};
|
|
13010
|
+
issue: string;
|
|
13011
|
+
sourceFile: string;
|
|
13012
|
+
targetFile: string;
|
|
13013
|
+
}, {
|
|
13014
|
+
unit: {
|
|
13015
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13016
|
+
id: string;
|
|
13017
|
+
};
|
|
13018
|
+
issue: string;
|
|
13019
|
+
sourceFile: string;
|
|
13020
|
+
targetFile: string;
|
|
13021
|
+
}>;
|
|
13022
|
+
|
|
13023
|
+
export declare const CopiedFileSchema: z.ZodObject<{
|
|
13024
|
+
source: z.ZodString;
|
|
13025
|
+
destination: z.ZodString;
|
|
13026
|
+
unit: z.ZodObject<{
|
|
13027
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13028
|
+
id: z.ZodString;
|
|
13029
|
+
}, "strip", z.ZodTypeAny, {
|
|
13030
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13031
|
+
id: string;
|
|
13032
|
+
}, {
|
|
13033
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13034
|
+
id: string;
|
|
13035
|
+
}>;
|
|
13036
|
+
}, "strip", z.ZodTypeAny, {
|
|
13037
|
+
source: string;
|
|
13038
|
+
destination: string;
|
|
13039
|
+
unit: {
|
|
13040
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13041
|
+
id: string;
|
|
13042
|
+
};
|
|
13043
|
+
}, {
|
|
13044
|
+
source: string;
|
|
13045
|
+
destination: string;
|
|
13046
|
+
unit: {
|
|
13047
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13048
|
+
id: string;
|
|
13049
|
+
};
|
|
13050
|
+
}>;
|
|
13051
|
+
|
|
13052
|
+
export declare const DiscoveryResultSchema: z.ZodObject<{
|
|
13053
|
+
units: z.ZodArray<z.ZodObject<{
|
|
13054
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13055
|
+
id: z.ZodString;
|
|
13056
|
+
file: z.ZodString;
|
|
13057
|
+
}, "strip", z.ZodTypeAny, {
|
|
13058
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13059
|
+
id: string;
|
|
13060
|
+
file: string;
|
|
13061
|
+
}, {
|
|
13062
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13063
|
+
id: string;
|
|
13064
|
+
file: string;
|
|
13065
|
+
}>, "many">;
|
|
13066
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13067
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13068
|
+
}, "strip", z.ZodTypeAny, {
|
|
13069
|
+
units: {
|
|
13070
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13071
|
+
id: string;
|
|
13072
|
+
file: string;
|
|
13073
|
+
}[];
|
|
13074
|
+
success?: boolean | undefined;
|
|
13075
|
+
error?: string | undefined;
|
|
13076
|
+
}, {
|
|
13077
|
+
units: {
|
|
13078
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13079
|
+
id: string;
|
|
13080
|
+
file: string;
|
|
13081
|
+
}[];
|
|
13082
|
+
success?: boolean | undefined;
|
|
13083
|
+
error?: string | undefined;
|
|
13084
|
+
}>;
|
|
13085
|
+
|
|
13086
|
+
export declare const exec: typeof exec_2.__promisify__;
|
|
13087
|
+
|
|
13088
|
+
export declare const execFile: typeof execFile_2.__promisify__;
|
|
13089
|
+
|
|
13090
|
+
export declare function fetchMastraTemplates(): Promise<Array<{
|
|
13091
|
+
slug: string;
|
|
13092
|
+
title: string;
|
|
13093
|
+
description: string;
|
|
13094
|
+
githubUrl: string;
|
|
13095
|
+
tags: string[];
|
|
13096
|
+
agents: string[];
|
|
13097
|
+
workflows: string[];
|
|
13098
|
+
tools: string[];
|
|
13099
|
+
}>>;
|
|
13100
|
+
|
|
13101
|
+
export declare const FileCopyInputSchema: z.ZodObject<{
|
|
13102
|
+
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
13103
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13104
|
+
id: z.ZodString;
|
|
13105
|
+
file: z.ZodString;
|
|
13106
|
+
}, "strip", z.ZodTypeAny, {
|
|
13107
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13108
|
+
id: string;
|
|
13109
|
+
file: string;
|
|
13110
|
+
}, {
|
|
13111
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13112
|
+
id: string;
|
|
13113
|
+
file: string;
|
|
13114
|
+
}>, "many">;
|
|
13115
|
+
templateDir: z.ZodString;
|
|
13116
|
+
commitSha: z.ZodString;
|
|
13117
|
+
slug: z.ZodString;
|
|
13118
|
+
targetPath: z.ZodOptional<z.ZodString>;
|
|
13119
|
+
}, "strip", z.ZodTypeAny, {
|
|
13120
|
+
slug: string;
|
|
13121
|
+
commitSha: string;
|
|
13122
|
+
templateDir: string;
|
|
13123
|
+
orderedUnits: {
|
|
13124
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13125
|
+
id: string;
|
|
13126
|
+
file: string;
|
|
13127
|
+
}[];
|
|
13128
|
+
targetPath?: string | undefined;
|
|
13129
|
+
}, {
|
|
13130
|
+
slug: string;
|
|
13131
|
+
commitSha: string;
|
|
13132
|
+
templateDir: string;
|
|
13133
|
+
orderedUnits: {
|
|
13134
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13135
|
+
id: string;
|
|
13136
|
+
file: string;
|
|
13137
|
+
}[];
|
|
13138
|
+
targetPath?: string | undefined;
|
|
13139
|
+
}>;
|
|
13140
|
+
|
|
13141
|
+
export declare const FileCopyResultSchema: z.ZodObject<{
|
|
13142
|
+
success: z.ZodBoolean;
|
|
13143
|
+
copiedFiles: z.ZodArray<z.ZodObject<{
|
|
13144
|
+
source: z.ZodString;
|
|
13145
|
+
destination: z.ZodString;
|
|
13146
|
+
unit: z.ZodObject<{
|
|
13147
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13148
|
+
id: z.ZodString;
|
|
13149
|
+
}, "strip", z.ZodTypeAny, {
|
|
13150
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13151
|
+
id: string;
|
|
13152
|
+
}, {
|
|
13153
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13154
|
+
id: string;
|
|
13155
|
+
}>;
|
|
13156
|
+
}, "strip", z.ZodTypeAny, {
|
|
13157
|
+
source: string;
|
|
13158
|
+
destination: string;
|
|
13159
|
+
unit: {
|
|
13160
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13161
|
+
id: string;
|
|
13162
|
+
};
|
|
13163
|
+
}, {
|
|
13164
|
+
source: string;
|
|
13165
|
+
destination: string;
|
|
13166
|
+
unit: {
|
|
13167
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13168
|
+
id: string;
|
|
13169
|
+
};
|
|
13170
|
+
}>, "many">;
|
|
13171
|
+
conflicts: z.ZodArray<z.ZodObject<{
|
|
13172
|
+
unit: z.ZodObject<{
|
|
13173
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13174
|
+
id: z.ZodString;
|
|
13175
|
+
}, "strip", z.ZodTypeAny, {
|
|
13176
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13177
|
+
id: string;
|
|
13178
|
+
}, {
|
|
13179
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13180
|
+
id: string;
|
|
13181
|
+
}>;
|
|
13182
|
+
issue: z.ZodString;
|
|
13183
|
+
sourceFile: z.ZodString;
|
|
13184
|
+
targetFile: z.ZodString;
|
|
13185
|
+
}, "strip", z.ZodTypeAny, {
|
|
13186
|
+
unit: {
|
|
13187
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13188
|
+
id: string;
|
|
13189
|
+
};
|
|
13190
|
+
issue: string;
|
|
13191
|
+
sourceFile: string;
|
|
13192
|
+
targetFile: string;
|
|
13193
|
+
}, {
|
|
13194
|
+
unit: {
|
|
13195
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13196
|
+
id: string;
|
|
13197
|
+
};
|
|
13198
|
+
issue: string;
|
|
13199
|
+
sourceFile: string;
|
|
13200
|
+
targetFile: string;
|
|
13201
|
+
}>, "many">;
|
|
13202
|
+
message: z.ZodString;
|
|
13203
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13204
|
+
}, "strip", z.ZodTypeAny, {
|
|
13205
|
+
message: string;
|
|
13206
|
+
success: boolean;
|
|
13207
|
+
copiedFiles: {
|
|
13208
|
+
source: string;
|
|
13209
|
+
destination: string;
|
|
13210
|
+
unit: {
|
|
13211
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13212
|
+
id: string;
|
|
13213
|
+
};
|
|
13214
|
+
}[];
|
|
13215
|
+
conflicts: {
|
|
13216
|
+
unit: {
|
|
13217
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13218
|
+
id: string;
|
|
13219
|
+
};
|
|
13220
|
+
issue: string;
|
|
13221
|
+
sourceFile: string;
|
|
13222
|
+
targetFile: string;
|
|
13223
|
+
}[];
|
|
13224
|
+
error?: string | undefined;
|
|
13225
|
+
}, {
|
|
13226
|
+
message: string;
|
|
13227
|
+
success: boolean;
|
|
13228
|
+
copiedFiles: {
|
|
13229
|
+
source: string;
|
|
13230
|
+
destination: string;
|
|
13231
|
+
unit: {
|
|
13232
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13233
|
+
id: string;
|
|
13234
|
+
};
|
|
13235
|
+
}[];
|
|
13236
|
+
conflicts: {
|
|
13237
|
+
unit: {
|
|
13238
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13239
|
+
id: string;
|
|
13240
|
+
};
|
|
13241
|
+
issue: string;
|
|
13242
|
+
sourceFile: string;
|
|
13243
|
+
targetFile: string;
|
|
13244
|
+
}[];
|
|
13245
|
+
error?: string | undefined;
|
|
13246
|
+
}>;
|
|
13247
|
+
|
|
13248
|
+
/**
|
|
13249
|
+
* Options for generating agents with AgentBuilder
|
|
13250
|
+
*/
|
|
13251
|
+
export declare interface GenerateAgentOptions {
|
|
13252
|
+
/** Runtime context for the generation */
|
|
13253
|
+
runtimeContext?: any;
|
|
13254
|
+
/** Output format preference */
|
|
13255
|
+
outputFormat?: 'code' | 'explanation' | 'both';
|
|
13256
|
+
}
|
|
13257
|
+
|
|
13258
|
+
export declare function getMastraTemplate(slug: string): Promise<{
|
|
13259
|
+
slug: string;
|
|
13260
|
+
title: string;
|
|
13261
|
+
description: string;
|
|
13262
|
+
githubUrl: string;
|
|
13263
|
+
tags: string[];
|
|
13264
|
+
agents: string[];
|
|
13265
|
+
workflows: string[];
|
|
13266
|
+
tools: string[];
|
|
13267
|
+
}>;
|
|
13268
|
+
|
|
13269
|
+
export declare function git(cwd: string, ...args: string[]): Promise<{
|
|
13270
|
+
stdout: string;
|
|
13271
|
+
stderr: string;
|
|
13272
|
+
}>;
|
|
13273
|
+
|
|
13274
|
+
export declare function gitAddAll(cwd: string): Promise<void>;
|
|
13275
|
+
|
|
13276
|
+
export declare function gitAddAndCommit(cwd: string, message: string, files?: string[], opts?: {
|
|
13277
|
+
allowEmpty?: boolean;
|
|
13278
|
+
skipIfNoStaged?: boolean;
|
|
13279
|
+
}): Promise<boolean>;
|
|
13280
|
+
|
|
13281
|
+
export declare function gitAddFiles(cwd: string, files: string[]): Promise<void>;
|
|
13282
|
+
|
|
13283
|
+
export declare function gitCheckoutBranch(branchName: string, targetPath: string): Promise<void>;
|
|
13284
|
+
|
|
13285
|
+
export declare function gitCheckoutRef(cwd: string, ref: string): Promise<void>;
|
|
13286
|
+
|
|
13287
|
+
export declare function gitClone(repo: string, destDir: string, cwd?: string): Promise<void>;
|
|
13288
|
+
|
|
13289
|
+
export declare function gitCommit(cwd: string, message: string, opts?: {
|
|
13290
|
+
allowEmpty?: boolean;
|
|
13291
|
+
skipIfNoStaged?: boolean;
|
|
13292
|
+
}): Promise<boolean>;
|
|
13293
|
+
|
|
13294
|
+
export declare function gitHasStagedChanges(cwd: string): Promise<boolean>;
|
|
13295
|
+
|
|
13296
|
+
export declare function gitRevParse(cwd: string, rev: string): Promise<string>;
|
|
13297
|
+
|
|
13298
|
+
export declare const InstallInputSchema: z.ZodObject<{
|
|
13299
|
+
targetPath: z.ZodString;
|
|
13300
|
+
}, "strip", z.ZodTypeAny, {
|
|
13301
|
+
targetPath: string;
|
|
13302
|
+
}, {
|
|
13303
|
+
targetPath: string;
|
|
13304
|
+
}>;
|
|
13305
|
+
|
|
13306
|
+
export declare const InstallResultSchema: z.ZodObject<{
|
|
13307
|
+
success: z.ZodBoolean;
|
|
13308
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13309
|
+
}, "strip", z.ZodTypeAny, {
|
|
13310
|
+
success: boolean;
|
|
13311
|
+
error?: string | undefined;
|
|
13312
|
+
}, {
|
|
13313
|
+
success: boolean;
|
|
13314
|
+
error?: string | undefined;
|
|
13315
|
+
}>;
|
|
13316
|
+
|
|
13317
|
+
export declare const IntelligentMergeInputSchema: z.ZodObject<{
|
|
13318
|
+
conflicts: z.ZodArray<z.ZodObject<{
|
|
13319
|
+
unit: z.ZodObject<{
|
|
13320
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13321
|
+
id: z.ZodString;
|
|
13322
|
+
}, "strip", z.ZodTypeAny, {
|
|
13323
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13324
|
+
id: string;
|
|
13325
|
+
}, {
|
|
13326
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13327
|
+
id: string;
|
|
13328
|
+
}>;
|
|
13329
|
+
issue: z.ZodString;
|
|
13330
|
+
sourceFile: z.ZodString;
|
|
13331
|
+
targetFile: z.ZodString;
|
|
13332
|
+
}, "strip", z.ZodTypeAny, {
|
|
13333
|
+
unit: {
|
|
13334
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13335
|
+
id: string;
|
|
13336
|
+
};
|
|
13337
|
+
issue: string;
|
|
13338
|
+
sourceFile: string;
|
|
13339
|
+
targetFile: string;
|
|
13340
|
+
}, {
|
|
13341
|
+
unit: {
|
|
13342
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13343
|
+
id: string;
|
|
13344
|
+
};
|
|
13345
|
+
issue: string;
|
|
13346
|
+
sourceFile: string;
|
|
13347
|
+
targetFile: string;
|
|
13348
|
+
}>, "many">;
|
|
13349
|
+
copiedFiles: z.ZodArray<z.ZodObject<{
|
|
13350
|
+
source: z.ZodString;
|
|
13351
|
+
destination: z.ZodString;
|
|
13352
|
+
unit: z.ZodObject<{
|
|
13353
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13354
|
+
id: z.ZodString;
|
|
13355
|
+
}, "strip", z.ZodTypeAny, {
|
|
13356
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13357
|
+
id: string;
|
|
13358
|
+
}, {
|
|
13359
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13360
|
+
id: string;
|
|
13361
|
+
}>;
|
|
13362
|
+
}, "strip", z.ZodTypeAny, {
|
|
13363
|
+
source: string;
|
|
13364
|
+
destination: string;
|
|
13365
|
+
unit: {
|
|
13366
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13367
|
+
id: string;
|
|
13368
|
+
};
|
|
13369
|
+
}, {
|
|
13370
|
+
source: string;
|
|
13371
|
+
destination: string;
|
|
13372
|
+
unit: {
|
|
13373
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13374
|
+
id: string;
|
|
13375
|
+
};
|
|
13376
|
+
}>, "many">;
|
|
13377
|
+
templateDir: z.ZodString;
|
|
13378
|
+
commitSha: z.ZodString;
|
|
13379
|
+
slug: z.ZodString;
|
|
13380
|
+
targetPath: z.ZodOptional<z.ZodString>;
|
|
13381
|
+
branchName: z.ZodOptional<z.ZodString>;
|
|
13382
|
+
}, "strip", z.ZodTypeAny, {
|
|
13383
|
+
slug: string;
|
|
13384
|
+
commitSha: string;
|
|
13385
|
+
templateDir: string;
|
|
13386
|
+
copiedFiles: {
|
|
13387
|
+
source: string;
|
|
13388
|
+
destination: string;
|
|
13389
|
+
unit: {
|
|
13390
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13391
|
+
id: string;
|
|
13392
|
+
};
|
|
13393
|
+
}[];
|
|
13394
|
+
conflicts: {
|
|
13395
|
+
unit: {
|
|
13396
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13397
|
+
id: string;
|
|
13398
|
+
};
|
|
13399
|
+
issue: string;
|
|
13400
|
+
sourceFile: string;
|
|
13401
|
+
targetFile: string;
|
|
13402
|
+
}[];
|
|
13403
|
+
targetPath?: string | undefined;
|
|
13404
|
+
branchName?: string | undefined;
|
|
13405
|
+
}, {
|
|
13406
|
+
slug: string;
|
|
13407
|
+
commitSha: string;
|
|
13408
|
+
templateDir: string;
|
|
13409
|
+
copiedFiles: {
|
|
13410
|
+
source: string;
|
|
13411
|
+
destination: string;
|
|
13412
|
+
unit: {
|
|
13413
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13414
|
+
id: string;
|
|
13415
|
+
};
|
|
13416
|
+
}[];
|
|
13417
|
+
conflicts: {
|
|
13418
|
+
unit: {
|
|
13419
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13420
|
+
id: string;
|
|
13421
|
+
};
|
|
13422
|
+
issue: string;
|
|
13423
|
+
sourceFile: string;
|
|
13424
|
+
targetFile: string;
|
|
13425
|
+
}[];
|
|
13426
|
+
targetPath?: string | undefined;
|
|
13427
|
+
branchName?: string | undefined;
|
|
13428
|
+
}>;
|
|
13429
|
+
|
|
13430
|
+
export declare const IntelligentMergeResultSchema: z.ZodObject<{
|
|
13431
|
+
success: z.ZodBoolean;
|
|
13432
|
+
applied: z.ZodBoolean;
|
|
13433
|
+
message: z.ZodString;
|
|
13434
|
+
conflictsResolved: z.ZodArray<z.ZodObject<{
|
|
13435
|
+
unit: z.ZodObject<{
|
|
13436
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13437
|
+
id: z.ZodString;
|
|
13438
|
+
}, "strip", z.ZodTypeAny, {
|
|
13439
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13440
|
+
id: string;
|
|
13441
|
+
}, {
|
|
13442
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13443
|
+
id: string;
|
|
13444
|
+
}>;
|
|
13445
|
+
issue: z.ZodString;
|
|
13446
|
+
resolution: z.ZodString;
|
|
13447
|
+
}, "strip", z.ZodTypeAny, {
|
|
13448
|
+
unit: {
|
|
13449
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13450
|
+
id: string;
|
|
13451
|
+
};
|
|
13452
|
+
issue: string;
|
|
13453
|
+
resolution: string;
|
|
13454
|
+
}, {
|
|
13455
|
+
unit: {
|
|
13456
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13457
|
+
id: string;
|
|
13458
|
+
};
|
|
13459
|
+
issue: string;
|
|
13460
|
+
resolution: string;
|
|
13461
|
+
}>, "many">;
|
|
13462
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13463
|
+
}, "strip", z.ZodTypeAny, {
|
|
13464
|
+
message: string;
|
|
13465
|
+
success: boolean;
|
|
13466
|
+
applied: boolean;
|
|
13467
|
+
conflictsResolved: {
|
|
13468
|
+
unit: {
|
|
13469
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13470
|
+
id: string;
|
|
13471
|
+
};
|
|
13472
|
+
issue: string;
|
|
13473
|
+
resolution: string;
|
|
13474
|
+
}[];
|
|
13475
|
+
error?: string | undefined;
|
|
13476
|
+
}, {
|
|
13477
|
+
message: string;
|
|
13478
|
+
success: boolean;
|
|
13479
|
+
applied: boolean;
|
|
13480
|
+
conflictsResolved: {
|
|
13481
|
+
unit: {
|
|
13482
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13483
|
+
id: string;
|
|
13484
|
+
};
|
|
13485
|
+
issue: string;
|
|
13486
|
+
resolution: string;
|
|
13487
|
+
}[];
|
|
13488
|
+
error?: string | undefined;
|
|
13489
|
+
}>;
|
|
13490
|
+
|
|
13491
|
+
export declare function isGitInstalled(): Promise<boolean>;
|
|
13492
|
+
|
|
13493
|
+
export declare function isInsideGitRepo(cwd: string): Promise<boolean>;
|
|
13494
|
+
|
|
13495
|
+
export declare function kindWeight(kind: UnitKind): number;
|
|
13496
|
+
|
|
13497
|
+
export declare function logGitState(targetPath: string, label: string): Promise<void>;
|
|
13498
|
+
|
|
13499
|
+
export declare interface MergePlan {
|
|
13500
|
+
slug: string;
|
|
13501
|
+
commitSha: string;
|
|
13502
|
+
templateDir: string;
|
|
13503
|
+
units: TemplateUnit[];
|
|
13504
|
+
}
|
|
13505
|
+
|
|
13506
|
+
export declare const MergePlanSchema: z.ZodObject<{
|
|
13507
|
+
slug: z.ZodString;
|
|
13508
|
+
commitSha: z.ZodString;
|
|
13509
|
+
templateDir: z.ZodString;
|
|
13510
|
+
units: z.ZodArray<z.ZodObject<{
|
|
13511
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
13512
|
+
id: z.ZodString;
|
|
13513
|
+
file: z.ZodString;
|
|
13514
|
+
}, "strip", z.ZodTypeAny, {
|
|
13515
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13516
|
+
id: string;
|
|
13517
|
+
file: string;
|
|
13518
|
+
}, {
|
|
13519
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13520
|
+
id: string;
|
|
13521
|
+
file: string;
|
|
13522
|
+
}>, "many">;
|
|
13523
|
+
}, "strip", z.ZodTypeAny, {
|
|
13524
|
+
slug: string;
|
|
13525
|
+
units: {
|
|
13526
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13527
|
+
id: string;
|
|
13528
|
+
file: string;
|
|
13529
|
+
}[];
|
|
13530
|
+
commitSha: string;
|
|
13531
|
+
templateDir: string;
|
|
13532
|
+
}, {
|
|
13533
|
+
slug: string;
|
|
13534
|
+
units: {
|
|
13535
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
13536
|
+
id: string;
|
|
13537
|
+
file: string;
|
|
13538
|
+
}[];
|
|
13539
|
+
commitSha: string;
|
|
13540
|
+
templateDir: string;
|
|
13541
|
+
}>;
|
|
13542
|
+
|
|
13543
|
+
declare function mergeTemplateBySlug(slug: string, targetPath?: string): Promise<WorkflowResult<z.ZodObject<{
|
|
13544
|
+
success: z.ZodBoolean;
|
|
13545
|
+
applied: z.ZodBoolean;
|
|
13546
|
+
branchName: z.ZodOptional<z.ZodString>;
|
|
13547
|
+
message: z.ZodString;
|
|
13548
|
+
validationResults: z.ZodOptional<z.ZodObject<{
|
|
13549
|
+
valid: z.ZodBoolean;
|
|
13550
|
+
errorsFixed: z.ZodNumber;
|
|
13551
|
+
remainingErrors: z.ZodNumber;
|
|
13552
|
+
}, "strip", z.ZodTypeAny, {
|
|
13553
|
+
valid: boolean;
|
|
13554
|
+
errorsFixed: number;
|
|
13555
|
+
remainingErrors: number;
|
|
13556
|
+
}, {
|
|
13557
|
+
valid: boolean;
|
|
13558
|
+
errorsFixed: number;
|
|
13559
|
+
remainingErrors: number;
|
|
13560
|
+
}>>;
|
|
13561
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13562
|
+
errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
13563
|
+
stepResults: z.ZodOptional<z.ZodObject<{
|
|
13564
|
+
cloneSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13565
|
+
analyzeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13566
|
+
discoverSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13567
|
+
orderSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13568
|
+
prepareBranchSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13569
|
+
packageMergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13570
|
+
installSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13571
|
+
copySuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13572
|
+
mergeSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13573
|
+
validationSuccess: z.ZodOptional<z.ZodBoolean>;
|
|
13574
|
+
filesCopied: z.ZodNumber;
|
|
13575
|
+
conflictsSkipped: z.ZodNumber;
|
|
13576
|
+
conflictsResolved: z.ZodNumber;
|
|
13577
|
+
}, "strip", z.ZodTypeAny, {
|
|
13578
|
+
conflictsResolved: number;
|
|
13579
|
+
filesCopied: number;
|
|
13580
|
+
conflictsSkipped: number;
|
|
13581
|
+
cloneSuccess?: boolean | undefined;
|
|
13582
|
+
analyzeSuccess?: boolean | undefined;
|
|
13583
|
+
discoverSuccess?: boolean | undefined;
|
|
13584
|
+
orderSuccess?: boolean | undefined;
|
|
13585
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
13586
|
+
packageMergeSuccess?: boolean | undefined;
|
|
13587
|
+
installSuccess?: boolean | undefined;
|
|
13588
|
+
copySuccess?: boolean | undefined;
|
|
13589
|
+
mergeSuccess?: boolean | undefined;
|
|
13590
|
+
validationSuccess?: boolean | undefined;
|
|
13591
|
+
}, {
|
|
13592
|
+
conflictsResolved: number;
|
|
13593
|
+
filesCopied: number;
|
|
13594
|
+
conflictsSkipped: number;
|
|
13595
|
+
cloneSuccess?: boolean | undefined;
|
|
13596
|
+
analyzeSuccess?: boolean | undefined;
|
|
13597
|
+
discoverSuccess?: boolean | undefined;
|
|
13598
|
+
orderSuccess?: boolean | undefined;
|
|
13599
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
13600
|
+
packageMergeSuccess?: boolean | undefined;
|
|
13601
|
+
installSuccess?: boolean | undefined;
|
|
13602
|
+
copySuccess?: boolean | undefined;
|
|
13603
|
+
mergeSuccess?: boolean | undefined;
|
|
13604
|
+
validationSuccess?: boolean | undefined;
|
|
13605
|
+
}>>;
|
|
13606
|
+
}, "strip", z.ZodTypeAny, {
|
|
13607
|
+
message: string;
|
|
13608
|
+
success: boolean;
|
|
13609
|
+
applied: boolean;
|
|
13610
|
+
error?: string | undefined;
|
|
13611
|
+
branchName?: string | undefined;
|
|
13612
|
+
validationResults?: {
|
|
13613
|
+
valid: boolean;
|
|
13614
|
+
errorsFixed: number;
|
|
13615
|
+
remainingErrors: number;
|
|
13616
|
+
} | undefined;
|
|
13617
|
+
errors?: string[] | undefined;
|
|
13618
|
+
stepResults?: {
|
|
13619
|
+
conflictsResolved: number;
|
|
13620
|
+
filesCopied: number;
|
|
13621
|
+
conflictsSkipped: number;
|
|
13622
|
+
cloneSuccess?: boolean | undefined;
|
|
13623
|
+
analyzeSuccess?: boolean | undefined;
|
|
13624
|
+
discoverSuccess?: boolean | undefined;
|
|
13625
|
+
orderSuccess?: boolean | undefined;
|
|
13626
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
13627
|
+
packageMergeSuccess?: boolean | undefined;
|
|
13628
|
+
installSuccess?: boolean | undefined;
|
|
13629
|
+
copySuccess?: boolean | undefined;
|
|
13630
|
+
mergeSuccess?: boolean | undefined;
|
|
13631
|
+
validationSuccess?: boolean | undefined;
|
|
13632
|
+
} | undefined;
|
|
13633
|
+
}, {
|
|
13634
|
+
message: string;
|
|
13635
|
+
success: boolean;
|
|
13636
|
+
applied: boolean;
|
|
13637
|
+
error?: string | undefined;
|
|
13638
|
+
branchName?: string | undefined;
|
|
13639
|
+
validationResults?: {
|
|
13640
|
+
valid: boolean;
|
|
13641
|
+
errorsFixed: number;
|
|
13642
|
+
remainingErrors: number;
|
|
13643
|
+
} | undefined;
|
|
13644
|
+
errors?: string[] | undefined;
|
|
13645
|
+
stepResults?: {
|
|
13646
|
+
conflictsResolved: number;
|
|
13647
|
+
filesCopied: number;
|
|
13648
|
+
conflictsSkipped: number;
|
|
13649
|
+
cloneSuccess?: boolean | undefined;
|
|
13650
|
+
analyzeSuccess?: boolean | undefined;
|
|
13651
|
+
discoverSuccess?: boolean | undefined;
|
|
13652
|
+
orderSuccess?: boolean | undefined;
|
|
13653
|
+
prepareBranchSuccess?: boolean | undefined;
|
|
13654
|
+
packageMergeSuccess?: boolean | undefined;
|
|
13655
|
+
installSuccess?: boolean | undefined;
|
|
13656
|
+
copySuccess?: boolean | undefined;
|
|
13657
|
+
mergeSuccess?: boolean | undefined;
|
|
13658
|
+
validationSuccess?: boolean | undefined;
|
|
13659
|
+
} | undefined;
|
|
13660
|
+
}>, (Step<"clone-template", z.ZodObject<{
|
|
13661
|
+
repo: z.ZodString;
|
|
13662
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
13663
|
+
slug: z.ZodOptional<z.ZodString>;
|
|
13664
|
+
targetPath: z.ZodOptional<z.ZodString>;
|
|
13665
|
+
}, "strip", z.ZodTypeAny, {
|
|
13666
|
+
repo: string;
|
|
13667
|
+
slug?: string | undefined;
|
|
13668
|
+
ref?: string | undefined;
|
|
13669
|
+
targetPath?: string | undefined;
|
|
13670
|
+
}, {
|
|
13671
|
+
repo: string;
|
|
13672
|
+
slug?: string | undefined;
|
|
13673
|
+
ref?: string | undefined;
|
|
13674
|
+
targetPath?: string | undefined;
|
|
13675
|
+
}>, z.ZodObject<{
|
|
13676
|
+
templateDir: z.ZodString;
|
|
13677
|
+
commitSha: z.ZodString;
|
|
13678
|
+
slug: z.ZodString;
|
|
13679
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13680
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13681
|
+
}, "strip", z.ZodTypeAny, {
|
|
13682
|
+
slug: string;
|
|
13683
|
+
commitSha: string;
|
|
13684
|
+
templateDir: string;
|
|
13685
|
+
success?: boolean | undefined;
|
|
13686
|
+
error?: string | undefined;
|
|
13687
|
+
}, {
|
|
13688
|
+
slug: string;
|
|
13689
|
+
commitSha: string;
|
|
13690
|
+
templateDir: string;
|
|
13691
|
+
success?: boolean | undefined;
|
|
13692
|
+
error?: string | undefined;
|
|
13693
|
+
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"analyze-package", z.ZodObject<{
|
|
13694
|
+
templateDir: z.ZodString;
|
|
13695
|
+
commitSha: z.ZodString;
|
|
13696
|
+
slug: z.ZodString;
|
|
13697
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13698
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13699
|
+
}, "strip", z.ZodTypeAny, {
|
|
13700
|
+
slug: string;
|
|
13701
|
+
commitSha: string;
|
|
13702
|
+
templateDir: string;
|
|
13703
|
+
success?: boolean | undefined;
|
|
13704
|
+
error?: string | undefined;
|
|
13705
|
+
}, {
|
|
13706
|
+
slug: string;
|
|
13707
|
+
commitSha: string;
|
|
13708
|
+
templateDir: string;
|
|
13709
|
+
success?: boolean | undefined;
|
|
13710
|
+
error?: string | undefined;
|
|
13711
|
+
}>, z.ZodObject<{
|
|
13712
|
+
name: z.ZodOptional<z.ZodString>;
|
|
13713
|
+
version: z.ZodOptional<z.ZodString>;
|
|
13714
|
+
description: z.ZodOptional<z.ZodString>;
|
|
13715
|
+
dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
13716
|
+
devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
13717
|
+
peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
13718
|
+
scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
13719
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13720
|
+
error: z.ZodOptional<z.ZodString>;
|
|
13721
|
+
}, "strip", z.ZodTypeAny, {
|
|
13722
|
+
description?: string | undefined;
|
|
13723
|
+
success?: boolean | undefined;
|
|
13724
|
+
error?: string | undefined;
|
|
13725
|
+
name?: string | undefined;
|
|
13726
|
+
version?: string | undefined;
|
|
13727
|
+
dependencies?: Record<string, string> | undefined;
|
|
13728
|
+
devDependencies?: Record<string, string> | undefined;
|
|
13729
|
+
peerDependencies?: Record<string, string> | undefined;
|
|
13730
|
+
scripts?: Record<string, string> | undefined;
|
|
13731
|
+
}, {
|
|
13732
|
+
description?: string | undefined;
|
|
13733
|
+
success?: boolean | undefined;
|
|
13734
|
+
error?: string | undefined;
|
|
13735
|
+
name?: string | undefined;
|
|
13736
|
+
version?: string | undefined;
|
|
12253
13737
|
dependencies?: Record<string, string> | undefined;
|
|
12254
13738
|
devDependencies?: Record<string, string> | undefined;
|
|
12255
13739
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -12258,14 +13742,20 @@ scripts?: Record<string, string> | undefined;
|
|
|
12258
13742
|
templateDir: z.ZodString;
|
|
12259
13743
|
commitSha: z.ZodString;
|
|
12260
13744
|
slug: z.ZodString;
|
|
13745
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13746
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12261
13747
|
}, "strip", z.ZodTypeAny, {
|
|
12262
13748
|
slug: string;
|
|
12263
13749
|
commitSha: string;
|
|
12264
13750
|
templateDir: string;
|
|
13751
|
+
success?: boolean | undefined;
|
|
13752
|
+
error?: string | undefined;
|
|
12265
13753
|
}, {
|
|
12266
13754
|
slug: string;
|
|
12267
13755
|
commitSha: string;
|
|
12268
13756
|
templateDir: string;
|
|
13757
|
+
success?: boolean | undefined;
|
|
13758
|
+
error?: string | undefined;
|
|
12269
13759
|
}>, z.ZodObject<{
|
|
12270
13760
|
units: z.ZodArray<z.ZodObject<{
|
|
12271
13761
|
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
@@ -12280,18 +13770,24 @@ kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" |
|
|
|
12280
13770
|
id: string;
|
|
12281
13771
|
file: string;
|
|
12282
13772
|
}>, "many">;
|
|
13773
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13774
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12283
13775
|
}, "strip", z.ZodTypeAny, {
|
|
12284
13776
|
units: {
|
|
12285
13777
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12286
13778
|
id: string;
|
|
12287
13779
|
file: string;
|
|
12288
13780
|
}[];
|
|
13781
|
+
success?: boolean | undefined;
|
|
13782
|
+
error?: string | undefined;
|
|
12289
13783
|
}, {
|
|
12290
13784
|
units: {
|
|
12291
13785
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12292
13786
|
id: string;
|
|
12293
13787
|
file: string;
|
|
12294
13788
|
}[];
|
|
13789
|
+
success?: boolean | undefined;
|
|
13790
|
+
error?: string | undefined;
|
|
12295
13791
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"order-units", z.ZodObject<{
|
|
12296
13792
|
units: z.ZodArray<z.ZodObject<{
|
|
12297
13793
|
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
@@ -12306,18 +13802,24 @@ kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" |
|
|
|
12306
13802
|
id: string;
|
|
12307
13803
|
file: string;
|
|
12308
13804
|
}>, "many">;
|
|
13805
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13806
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12309
13807
|
}, "strip", z.ZodTypeAny, {
|
|
12310
13808
|
units: {
|
|
12311
13809
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12312
13810
|
id: string;
|
|
12313
13811
|
file: string;
|
|
12314
13812
|
}[];
|
|
13813
|
+
success?: boolean | undefined;
|
|
13814
|
+
error?: string | undefined;
|
|
12315
13815
|
}, {
|
|
12316
13816
|
units: {
|
|
12317
13817
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12318
13818
|
id: string;
|
|
12319
13819
|
file: string;
|
|
12320
13820
|
}[];
|
|
13821
|
+
success?: boolean | undefined;
|
|
13822
|
+
error?: string | undefined;
|
|
12321
13823
|
}>, z.ZodObject<{
|
|
12322
13824
|
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
12323
13825
|
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
@@ -12332,56 +13834,54 @@ kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" |
|
|
|
12332
13834
|
id: string;
|
|
12333
13835
|
file: string;
|
|
12334
13836
|
}>, "many">;
|
|
13837
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13838
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12335
13839
|
}, "strip", z.ZodTypeAny, {
|
|
12336
13840
|
orderedUnits: {
|
|
12337
13841
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12338
13842
|
id: string;
|
|
12339
13843
|
file: string;
|
|
12340
13844
|
}[];
|
|
13845
|
+
success?: boolean | undefined;
|
|
13846
|
+
error?: string | undefined;
|
|
12341
13847
|
}, {
|
|
12342
13848
|
orderedUnits: {
|
|
12343
13849
|
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12344
13850
|
id: string;
|
|
12345
13851
|
file: string;
|
|
12346
13852
|
}[];
|
|
13853
|
+
success?: boolean | undefined;
|
|
13854
|
+
error?: string | undefined;
|
|
12347
13855
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"package-merge", z.ZodObject<{
|
|
12348
13856
|
commitSha: z.ZodString;
|
|
12349
13857
|
slug: z.ZodString;
|
|
12350
13858
|
targetPath: z.ZodOptional<z.ZodString>;
|
|
12351
13859
|
packageInfo: z.ZodObject<{
|
|
13860
|
+
name: z.ZodOptional<z.ZodString>;
|
|
13861
|
+
version: z.ZodOptional<z.ZodString>;
|
|
13862
|
+
description: z.ZodOptional<z.ZodString>;
|
|
12352
13863
|
dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
12353
13864
|
devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
12354
13865
|
peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
12355
13866
|
scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
12356
|
-
|
|
12357
|
-
|
|
12358
|
-
version: z.ZodOptional<z.ZodString>;
|
|
12359
|
-
description: z.ZodOptional<z.ZodString>;
|
|
12360
|
-
}, "strip", z.ZodTypeAny, {
|
|
12361
|
-
description?: string | undefined;
|
|
12362
|
-
name?: string | undefined;
|
|
12363
|
-
version?: string | undefined;
|
|
12364
|
-
}, {
|
|
12365
|
-
description?: string | undefined;
|
|
12366
|
-
name?: string | undefined;
|
|
12367
|
-
version?: string | undefined;
|
|
12368
|
-
}>;
|
|
13867
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
13868
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12369
13869
|
}, "strip", z.ZodTypeAny, {
|
|
12370
|
-
packageInfo: {
|
|
12371
13870
|
description?: string | undefined;
|
|
13871
|
+
success?: boolean | undefined;
|
|
13872
|
+
error?: string | undefined;
|
|
12372
13873
|
name?: string | undefined;
|
|
12373
13874
|
version?: string | undefined;
|
|
12374
|
-
};
|
|
12375
13875
|
dependencies?: Record<string, string> | undefined;
|
|
12376
13876
|
devDependencies?: Record<string, string> | undefined;
|
|
12377
13877
|
peerDependencies?: Record<string, string> | undefined;
|
|
12378
13878
|
scripts?: Record<string, string> | undefined;
|
|
12379
13879
|
}, {
|
|
12380
|
-
packageInfo: {
|
|
12381
13880
|
description?: string | undefined;
|
|
13881
|
+
success?: boolean | undefined;
|
|
13882
|
+
error?: string | undefined;
|
|
12382
13883
|
name?: string | undefined;
|
|
12383
13884
|
version?: string | undefined;
|
|
12384
|
-
};
|
|
12385
13885
|
dependencies?: Record<string, string> | undefined;
|
|
12386
13886
|
devDependencies?: Record<string, string> | undefined;
|
|
12387
13887
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -12391,11 +13891,11 @@ scripts?: Record<string, string> | undefined;
|
|
|
12391
13891
|
slug: string;
|
|
12392
13892
|
commitSha: string;
|
|
12393
13893
|
packageInfo: {
|
|
12394
|
-
packageInfo: {
|
|
12395
13894
|
description?: string | undefined;
|
|
13895
|
+
success?: boolean | undefined;
|
|
13896
|
+
error?: string | undefined;
|
|
12396
13897
|
name?: string | undefined;
|
|
12397
13898
|
version?: string | undefined;
|
|
12398
|
-
};
|
|
12399
13899
|
dependencies?: Record<string, string> | undefined;
|
|
12400
13900
|
devDependencies?: Record<string, string> | undefined;
|
|
12401
13901
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -12406,11 +13906,11 @@ targetPath?: string | undefined;
|
|
|
12406
13906
|
slug: string;
|
|
12407
13907
|
commitSha: string;
|
|
12408
13908
|
packageInfo: {
|
|
12409
|
-
packageInfo: {
|
|
12410
13909
|
description?: string | undefined;
|
|
13910
|
+
success?: boolean | undefined;
|
|
13911
|
+
error?: string | undefined;
|
|
12411
13912
|
name?: string | undefined;
|
|
12412
13913
|
version?: string | undefined;
|
|
12413
|
-
};
|
|
12414
13914
|
dependencies?: Record<string, string> | undefined;
|
|
12415
13915
|
devDependencies?: Record<string, string> | undefined;
|
|
12416
13916
|
peerDependencies?: Record<string, string> | undefined;
|
|
@@ -12432,7 +13932,7 @@ message: string;
|
|
|
12432
13932
|
success: boolean;
|
|
12433
13933
|
applied: boolean;
|
|
12434
13934
|
error?: string | undefined;
|
|
12435
|
-
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"
|
|
13935
|
+
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"install", z.ZodObject<{
|
|
12436
13936
|
targetPath: z.ZodString;
|
|
12437
13937
|
}, "strip", z.ZodTypeAny, {
|
|
12438
13938
|
targetPath: string;
|
|
@@ -12440,27 +13940,24 @@ targetPath: string;
|
|
|
12440
13940
|
targetPath: string;
|
|
12441
13941
|
}>, z.ZodObject<{
|
|
12442
13942
|
success: z.ZodBoolean;
|
|
12443
|
-
|
|
12444
|
-
details: z.ZodOptional<z.ZodString>;
|
|
13943
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12445
13944
|
}, "strip", z.ZodTypeAny, {
|
|
12446
|
-
message: string;
|
|
12447
13945
|
success: boolean;
|
|
12448
|
-
|
|
13946
|
+
error?: string | undefined;
|
|
12449
13947
|
}, {
|
|
12450
|
-
message: string;
|
|
12451
13948
|
success: boolean;
|
|
12452
|
-
|
|
13949
|
+
error?: string | undefined;
|
|
12453
13950
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"programmatic-file-copy", z.ZodObject<{
|
|
12454
13951
|
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
12455
|
-
kind: z.
|
|
13952
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12456
13953
|
id: z.ZodString;
|
|
12457
13954
|
file: z.ZodString;
|
|
12458
13955
|
}, "strip", z.ZodTypeAny, {
|
|
12459
|
-
kind:
|
|
13956
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12460
13957
|
id: string;
|
|
12461
13958
|
file: string;
|
|
12462
13959
|
}, {
|
|
12463
|
-
kind:
|
|
13960
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12464
13961
|
id: string;
|
|
12465
13962
|
file: string;
|
|
12466
13963
|
}>, "many">;
|
|
@@ -12473,7 +13970,7 @@ slug: string;
|
|
|
12473
13970
|
commitSha: string;
|
|
12474
13971
|
templateDir: string;
|
|
12475
13972
|
orderedUnits: {
|
|
12476
|
-
kind:
|
|
13973
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12477
13974
|
id: string;
|
|
12478
13975
|
file: string;
|
|
12479
13976
|
}[];
|
|
@@ -12483,7 +13980,7 @@ slug: string;
|
|
|
12483
13980
|
commitSha: string;
|
|
12484
13981
|
templateDir: string;
|
|
12485
13982
|
orderedUnits: {
|
|
12486
|
-
kind:
|
|
13983
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12487
13984
|
id: string;
|
|
12488
13985
|
file: string;
|
|
12489
13986
|
}[];
|
|
@@ -12494,39 +13991,39 @@ copiedFiles: z.ZodArray<z.ZodObject<{
|
|
|
12494
13991
|
source: z.ZodString;
|
|
12495
13992
|
destination: z.ZodString;
|
|
12496
13993
|
unit: z.ZodObject<{
|
|
12497
|
-
kind: z.
|
|
13994
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12498
13995
|
id: z.ZodString;
|
|
12499
13996
|
}, "strip", z.ZodTypeAny, {
|
|
12500
|
-
kind:
|
|
13997
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12501
13998
|
id: string;
|
|
12502
13999
|
}, {
|
|
12503
|
-
kind:
|
|
14000
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12504
14001
|
id: string;
|
|
12505
14002
|
}>;
|
|
12506
14003
|
}, "strip", z.ZodTypeAny, {
|
|
12507
14004
|
source: string;
|
|
12508
14005
|
destination: string;
|
|
12509
14006
|
unit: {
|
|
12510
|
-
kind:
|
|
14007
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12511
14008
|
id: string;
|
|
12512
14009
|
};
|
|
12513
14010
|
}, {
|
|
12514
14011
|
source: string;
|
|
12515
14012
|
destination: string;
|
|
12516
14013
|
unit: {
|
|
12517
|
-
kind:
|
|
14014
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12518
14015
|
id: string;
|
|
12519
14016
|
};
|
|
12520
14017
|
}>, "many">;
|
|
12521
14018
|
conflicts: z.ZodArray<z.ZodObject<{
|
|
12522
14019
|
unit: z.ZodObject<{
|
|
12523
|
-
kind: z.
|
|
14020
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12524
14021
|
id: z.ZodString;
|
|
12525
14022
|
}, "strip", z.ZodTypeAny, {
|
|
12526
|
-
kind:
|
|
14023
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12527
14024
|
id: string;
|
|
12528
14025
|
}, {
|
|
12529
|
-
kind:
|
|
14026
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12530
14027
|
id: string;
|
|
12531
14028
|
}>;
|
|
12532
14029
|
issue: z.ZodString;
|
|
@@ -12534,7 +14031,7 @@ sourceFile: z.ZodString;
|
|
|
12534
14031
|
targetFile: z.ZodString;
|
|
12535
14032
|
}, "strip", z.ZodTypeAny, {
|
|
12536
14033
|
unit: {
|
|
12537
|
-
kind:
|
|
14034
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12538
14035
|
id: string;
|
|
12539
14036
|
};
|
|
12540
14037
|
issue: string;
|
|
@@ -12542,7 +14039,7 @@ sourceFile: string;
|
|
|
12542
14039
|
targetFile: string;
|
|
12543
14040
|
}, {
|
|
12544
14041
|
unit: {
|
|
12545
|
-
kind:
|
|
14042
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12546
14043
|
id: string;
|
|
12547
14044
|
};
|
|
12548
14045
|
issue: string;
|
|
@@ -12558,13 +14055,13 @@ copiedFiles: {
|
|
|
12558
14055
|
source: string;
|
|
12559
14056
|
destination: string;
|
|
12560
14057
|
unit: {
|
|
12561
|
-
kind:
|
|
14058
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12562
14059
|
id: string;
|
|
12563
14060
|
};
|
|
12564
14061
|
}[];
|
|
12565
14062
|
conflicts: {
|
|
12566
14063
|
unit: {
|
|
12567
|
-
kind:
|
|
14064
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12568
14065
|
id: string;
|
|
12569
14066
|
};
|
|
12570
14067
|
issue: string;
|
|
@@ -12579,13 +14076,13 @@ copiedFiles: {
|
|
|
12579
14076
|
source: string;
|
|
12580
14077
|
destination: string;
|
|
12581
14078
|
unit: {
|
|
12582
|
-
kind:
|
|
14079
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12583
14080
|
id: string;
|
|
12584
14081
|
};
|
|
12585
14082
|
}[];
|
|
12586
14083
|
conflicts: {
|
|
12587
14084
|
unit: {
|
|
12588
|
-
kind:
|
|
14085
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12589
14086
|
id: string;
|
|
12590
14087
|
};
|
|
12591
14088
|
issue: string;
|
|
@@ -12596,13 +14093,13 @@ error?: string | undefined;
|
|
|
12596
14093
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"intelligent-merge", z.ZodObject<{
|
|
12597
14094
|
conflicts: z.ZodArray<z.ZodObject<{
|
|
12598
14095
|
unit: z.ZodObject<{
|
|
12599
|
-
kind: z.
|
|
14096
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12600
14097
|
id: z.ZodString;
|
|
12601
14098
|
}, "strip", z.ZodTypeAny, {
|
|
12602
|
-
kind:
|
|
14099
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12603
14100
|
id: string;
|
|
12604
14101
|
}, {
|
|
12605
|
-
kind:
|
|
14102
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12606
14103
|
id: string;
|
|
12607
14104
|
}>;
|
|
12608
14105
|
issue: z.ZodString;
|
|
@@ -12610,7 +14107,7 @@ sourceFile: z.ZodString;
|
|
|
12610
14107
|
targetFile: z.ZodString;
|
|
12611
14108
|
}, "strip", z.ZodTypeAny, {
|
|
12612
14109
|
unit: {
|
|
12613
|
-
kind:
|
|
14110
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12614
14111
|
id: string;
|
|
12615
14112
|
};
|
|
12616
14113
|
issue: string;
|
|
@@ -12618,7 +14115,7 @@ sourceFile: string;
|
|
|
12618
14115
|
targetFile: string;
|
|
12619
14116
|
}, {
|
|
12620
14117
|
unit: {
|
|
12621
|
-
kind:
|
|
14118
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12622
14119
|
id: string;
|
|
12623
14120
|
};
|
|
12624
14121
|
issue: string;
|
|
@@ -12629,27 +14126,27 @@ copiedFiles: z.ZodArray<z.ZodObject<{
|
|
|
12629
14126
|
source: z.ZodString;
|
|
12630
14127
|
destination: z.ZodString;
|
|
12631
14128
|
unit: z.ZodObject<{
|
|
12632
|
-
kind: z.
|
|
14129
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12633
14130
|
id: z.ZodString;
|
|
12634
14131
|
}, "strip", z.ZodTypeAny, {
|
|
12635
|
-
kind:
|
|
14132
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12636
14133
|
id: string;
|
|
12637
14134
|
}, {
|
|
12638
|
-
kind:
|
|
14135
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12639
14136
|
id: string;
|
|
12640
14137
|
}>;
|
|
12641
14138
|
}, "strip", z.ZodTypeAny, {
|
|
12642
14139
|
source: string;
|
|
12643
14140
|
destination: string;
|
|
12644
14141
|
unit: {
|
|
12645
|
-
kind:
|
|
14142
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12646
14143
|
id: string;
|
|
12647
14144
|
};
|
|
12648
14145
|
}, {
|
|
12649
14146
|
source: string;
|
|
12650
14147
|
destination: string;
|
|
12651
14148
|
unit: {
|
|
12652
|
-
kind:
|
|
14149
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12653
14150
|
id: string;
|
|
12654
14151
|
};
|
|
12655
14152
|
}>, "many">;
|
|
@@ -12657,6 +14154,7 @@ templateDir: z.ZodString;
|
|
|
12657
14154
|
commitSha: z.ZodString;
|
|
12658
14155
|
slug: z.ZodString;
|
|
12659
14156
|
targetPath: z.ZodOptional<z.ZodString>;
|
|
14157
|
+
branchName: z.ZodOptional<z.ZodString>;
|
|
12660
14158
|
}, "strip", z.ZodTypeAny, {
|
|
12661
14159
|
slug: string;
|
|
12662
14160
|
commitSha: string;
|
|
@@ -12665,13 +14163,13 @@ copiedFiles: {
|
|
|
12665
14163
|
source: string;
|
|
12666
14164
|
destination: string;
|
|
12667
14165
|
unit: {
|
|
12668
|
-
kind:
|
|
14166
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12669
14167
|
id: string;
|
|
12670
14168
|
};
|
|
12671
14169
|
}[];
|
|
12672
14170
|
conflicts: {
|
|
12673
14171
|
unit: {
|
|
12674
|
-
kind:
|
|
14172
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12675
14173
|
id: string;
|
|
12676
14174
|
};
|
|
12677
14175
|
issue: string;
|
|
@@ -12679,6 +14177,7 @@ sourceFile: string;
|
|
|
12679
14177
|
targetFile: string;
|
|
12680
14178
|
}[];
|
|
12681
14179
|
targetPath?: string | undefined;
|
|
14180
|
+
branchName?: string | undefined;
|
|
12682
14181
|
}, {
|
|
12683
14182
|
slug: string;
|
|
12684
14183
|
commitSha: string;
|
|
@@ -12687,13 +14186,13 @@ copiedFiles: {
|
|
|
12687
14186
|
source: string;
|
|
12688
14187
|
destination: string;
|
|
12689
14188
|
unit: {
|
|
12690
|
-
kind:
|
|
14189
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12691
14190
|
id: string;
|
|
12692
14191
|
};
|
|
12693
14192
|
}[];
|
|
12694
14193
|
conflicts: {
|
|
12695
14194
|
unit: {
|
|
12696
|
-
kind:
|
|
14195
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12697
14196
|
id: string;
|
|
12698
14197
|
};
|
|
12699
14198
|
issue: string;
|
|
@@ -12701,53 +14200,52 @@ sourceFile: string;
|
|
|
12701
14200
|
targetFile: string;
|
|
12702
14201
|
}[];
|
|
12703
14202
|
targetPath?: string | undefined;
|
|
14203
|
+
branchName?: string | undefined;
|
|
12704
14204
|
}>, z.ZodObject<{
|
|
12705
14205
|
success: z.ZodBoolean;
|
|
12706
14206
|
applied: z.ZodBoolean;
|
|
12707
14207
|
message: z.ZodString;
|
|
12708
14208
|
conflictsResolved: z.ZodArray<z.ZodObject<{
|
|
12709
14209
|
unit: z.ZodObject<{
|
|
12710
|
-
kind: z.
|
|
14210
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12711
14211
|
id: z.ZodString;
|
|
12712
14212
|
}, "strip", z.ZodTypeAny, {
|
|
12713
|
-
kind:
|
|
14213
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12714
14214
|
id: string;
|
|
12715
14215
|
}, {
|
|
12716
|
-
kind:
|
|
14216
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12717
14217
|
id: string;
|
|
12718
14218
|
}>;
|
|
12719
14219
|
issue: z.ZodString;
|
|
12720
14220
|
resolution: z.ZodString;
|
|
12721
14221
|
}, "strip", z.ZodTypeAny, {
|
|
12722
14222
|
unit: {
|
|
12723
|
-
kind:
|
|
14223
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12724
14224
|
id: string;
|
|
12725
14225
|
};
|
|
12726
14226
|
issue: string;
|
|
12727
14227
|
resolution: string;
|
|
12728
14228
|
}, {
|
|
12729
14229
|
unit: {
|
|
12730
|
-
kind:
|
|
14230
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12731
14231
|
id: string;
|
|
12732
14232
|
};
|
|
12733
14233
|
issue: string;
|
|
12734
14234
|
resolution: string;
|
|
12735
14235
|
}>, "many">;
|
|
12736
14236
|
error: z.ZodOptional<z.ZodString>;
|
|
12737
|
-
branchName: z.ZodOptional<z.ZodString>;
|
|
12738
14237
|
}, "strip", z.ZodTypeAny, {
|
|
12739
14238
|
message: string;
|
|
12740
14239
|
success: boolean;
|
|
12741
14240
|
applied: boolean;
|
|
12742
14241
|
conflictsResolved: {
|
|
12743
14242
|
unit: {
|
|
12744
|
-
kind:
|
|
14243
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12745
14244
|
id: string;
|
|
12746
14245
|
};
|
|
12747
14246
|
issue: string;
|
|
12748
14247
|
resolution: string;
|
|
12749
14248
|
}[];
|
|
12750
|
-
branchName?: string | undefined;
|
|
12751
14249
|
error?: string | undefined;
|
|
12752
14250
|
}, {
|
|
12753
14251
|
message: string;
|
|
@@ -12755,13 +14253,12 @@ success: boolean;
|
|
|
12755
14253
|
applied: boolean;
|
|
12756
14254
|
conflictsResolved: {
|
|
12757
14255
|
unit: {
|
|
12758
|
-
kind:
|
|
14256
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12759
14257
|
id: string;
|
|
12760
14258
|
};
|
|
12761
14259
|
issue: string;
|
|
12762
14260
|
resolution: string;
|
|
12763
14261
|
}[];
|
|
12764
|
-
branchName?: string | undefined;
|
|
12765
14262
|
error?: string | undefined;
|
|
12766
14263
|
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType> | Step<"validation-and-fix", z.ZodObject<{
|
|
12767
14264
|
commitSha: z.ZodString;
|
|
@@ -12769,15 +14266,15 @@ slug: z.ZodString;
|
|
|
12769
14266
|
targetPath: z.ZodOptional<z.ZodString>;
|
|
12770
14267
|
templateDir: z.ZodString;
|
|
12771
14268
|
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
12772
|
-
kind: z.
|
|
14269
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12773
14270
|
id: z.ZodString;
|
|
12774
14271
|
file: z.ZodString;
|
|
12775
14272
|
}, "strip", z.ZodTypeAny, {
|
|
12776
|
-
kind:
|
|
14273
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12777
14274
|
id: string;
|
|
12778
14275
|
file: string;
|
|
12779
14276
|
}, {
|
|
12780
|
-
kind:
|
|
14277
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12781
14278
|
id: string;
|
|
12782
14279
|
file: string;
|
|
12783
14280
|
}>, "many">;
|
|
@@ -12785,53 +14282,53 @@ copiedFiles: z.ZodArray<z.ZodObject<{
|
|
|
12785
14282
|
source: z.ZodString;
|
|
12786
14283
|
destination: z.ZodString;
|
|
12787
14284
|
unit: z.ZodObject<{
|
|
12788
|
-
kind: z.
|
|
14285
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12789
14286
|
id: z.ZodString;
|
|
12790
14287
|
}, "strip", z.ZodTypeAny, {
|
|
12791
|
-
kind:
|
|
14288
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12792
14289
|
id: string;
|
|
12793
14290
|
}, {
|
|
12794
|
-
kind:
|
|
14291
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12795
14292
|
id: string;
|
|
12796
14293
|
}>;
|
|
12797
14294
|
}, "strip", z.ZodTypeAny, {
|
|
12798
14295
|
source: string;
|
|
12799
14296
|
destination: string;
|
|
12800
14297
|
unit: {
|
|
12801
|
-
kind:
|
|
14298
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12802
14299
|
id: string;
|
|
12803
14300
|
};
|
|
12804
14301
|
}, {
|
|
12805
14302
|
source: string;
|
|
12806
14303
|
destination: string;
|
|
12807
14304
|
unit: {
|
|
12808
|
-
kind:
|
|
14305
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12809
14306
|
id: string;
|
|
12810
14307
|
};
|
|
12811
14308
|
}>, "many">;
|
|
12812
14309
|
conflictsResolved: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
12813
14310
|
unit: z.ZodObject<{
|
|
12814
|
-
kind: z.
|
|
14311
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
12815
14312
|
id: z.ZodString;
|
|
12816
14313
|
}, "strip", z.ZodTypeAny, {
|
|
12817
|
-
kind:
|
|
14314
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12818
14315
|
id: string;
|
|
12819
14316
|
}, {
|
|
12820
|
-
kind:
|
|
14317
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12821
14318
|
id: string;
|
|
12822
14319
|
}>;
|
|
12823
14320
|
issue: z.ZodString;
|
|
12824
14321
|
resolution: z.ZodString;
|
|
12825
14322
|
}, "strip", z.ZodTypeAny, {
|
|
12826
14323
|
unit: {
|
|
12827
|
-
kind:
|
|
14324
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12828
14325
|
id: string;
|
|
12829
14326
|
};
|
|
12830
14327
|
issue: string;
|
|
12831
14328
|
resolution: string;
|
|
12832
14329
|
}, {
|
|
12833
14330
|
unit: {
|
|
12834
|
-
kind:
|
|
14331
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12835
14332
|
id: string;
|
|
12836
14333
|
};
|
|
12837
14334
|
issue: string;
|
|
@@ -12843,7 +14340,7 @@ slug: string;
|
|
|
12843
14340
|
commitSha: string;
|
|
12844
14341
|
templateDir: string;
|
|
12845
14342
|
orderedUnits: {
|
|
12846
|
-
kind:
|
|
14343
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12847
14344
|
id: string;
|
|
12848
14345
|
file: string;
|
|
12849
14346
|
}[];
|
|
@@ -12851,7 +14348,7 @@ copiedFiles: {
|
|
|
12851
14348
|
source: string;
|
|
12852
14349
|
destination: string;
|
|
12853
14350
|
unit: {
|
|
12854
|
-
kind:
|
|
14351
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12855
14352
|
id: string;
|
|
12856
14353
|
};
|
|
12857
14354
|
}[];
|
|
@@ -12859,7 +14356,7 @@ maxIterations: number;
|
|
|
12859
14356
|
targetPath?: string | undefined;
|
|
12860
14357
|
conflictsResolved?: {
|
|
12861
14358
|
unit: {
|
|
12862
|
-
kind:
|
|
14359
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12863
14360
|
id: string;
|
|
12864
14361
|
};
|
|
12865
14362
|
issue: string;
|
|
@@ -12870,7 +14367,7 @@ slug: string;
|
|
|
12870
14367
|
commitSha: string;
|
|
12871
14368
|
templateDir: string;
|
|
12872
14369
|
orderedUnits: {
|
|
12873
|
-
kind:
|
|
14370
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12874
14371
|
id: string;
|
|
12875
14372
|
file: string;
|
|
12876
14373
|
}[];
|
|
@@ -12878,14 +14375,14 @@ copiedFiles: {
|
|
|
12878
14375
|
source: string;
|
|
12879
14376
|
destination: string;
|
|
12880
14377
|
unit: {
|
|
12881
|
-
kind:
|
|
14378
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12882
14379
|
id: string;
|
|
12883
14380
|
};
|
|
12884
14381
|
}[];
|
|
12885
14382
|
targetPath?: string | undefined;
|
|
12886
14383
|
conflictsResolved?: {
|
|
12887
14384
|
unit: {
|
|
12888
|
-
kind:
|
|
14385
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
12889
14386
|
id: string;
|
|
12890
14387
|
};
|
|
12891
14388
|
issue: string;
|
|
@@ -12930,58 +14427,194 @@ errorsFixed: number;
|
|
|
12930
14427
|
remainingErrors: number;
|
|
12931
14428
|
};
|
|
12932
14429
|
error?: string | undefined;
|
|
12933
|
-
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType>)[]
|
|
12934
|
-
|
|
12935
|
-
|
|
12936
|
-
|
|
12937
|
-
|
|
12938
|
-
|
|
12939
|
-
|
|
12940
|
-
|
|
12941
|
-
|
|
12942
|
-
|
|
12943
|
-
}, {
|
|
12944
|
-
|
|
12945
|
-
|
|
12946
|
-
|
|
12947
|
-
|
|
12948
|
-
|
|
12949
|
-
|
|
12950
|
-
|
|
12951
|
-
|
|
12952
|
-
|
|
14430
|
+
}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, DefaultEngineType>)[]>>;
|
|
14431
|
+
export { mergeTemplateBySlug }
|
|
14432
|
+
export { mergeTemplateBySlug as mergeTemplateBySlug_alias_1 }
|
|
14433
|
+
export { mergeTemplateBySlug as mergeTemplateBySlug_alias_2 }
|
|
14434
|
+
|
|
14435
|
+
export declare const OrderedUnitsSchema: z.ZodObject<{
|
|
14436
|
+
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
14437
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
14438
|
+
id: z.ZodString;
|
|
14439
|
+
file: z.ZodString;
|
|
14440
|
+
}, "strip", z.ZodTypeAny, {
|
|
14441
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14442
|
+
id: string;
|
|
14443
|
+
file: string;
|
|
14444
|
+
}, {
|
|
14445
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14446
|
+
id: string;
|
|
14447
|
+
file: string;
|
|
14448
|
+
}>, "many">;
|
|
14449
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
14450
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12953
14451
|
}, "strip", z.ZodTypeAny, {
|
|
12954
|
-
|
|
12955
|
-
|
|
12956
|
-
|
|
12957
|
-
|
|
14452
|
+
orderedUnits: {
|
|
14453
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14454
|
+
id: string;
|
|
14455
|
+
file: string;
|
|
14456
|
+
}[];
|
|
14457
|
+
success?: boolean | undefined;
|
|
14458
|
+
error?: string | undefined;
|
|
12958
14459
|
}, {
|
|
12959
|
-
|
|
12960
|
-
|
|
12961
|
-
|
|
12962
|
-
|
|
12963
|
-
}
|
|
12964
|
-
success
|
|
12965
|
-
|
|
12966
|
-
|
|
12967
|
-
|
|
14460
|
+
orderedUnits: {
|
|
14461
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14462
|
+
id: string;
|
|
14463
|
+
file: string;
|
|
14464
|
+
}[];
|
|
14465
|
+
success?: boolean | undefined;
|
|
14466
|
+
error?: string | undefined;
|
|
14467
|
+
}>;
|
|
14468
|
+
|
|
14469
|
+
export declare const PackageAnalysisSchema: z.ZodObject<{
|
|
14470
|
+
name: z.ZodOptional<z.ZodString>;
|
|
14471
|
+
version: z.ZodOptional<z.ZodString>;
|
|
14472
|
+
description: z.ZodOptional<z.ZodString>;
|
|
14473
|
+
dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14474
|
+
devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14475
|
+
peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14476
|
+
scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14477
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
14478
|
+
error: z.ZodOptional<z.ZodString>;
|
|
12968
14479
|
}, "strip", z.ZodTypeAny, {
|
|
12969
|
-
|
|
12970
|
-
|
|
12971
|
-
|
|
12972
|
-
|
|
14480
|
+
description?: string | undefined;
|
|
14481
|
+
success?: boolean | undefined;
|
|
14482
|
+
error?: string | undefined;
|
|
14483
|
+
name?: string | undefined;
|
|
14484
|
+
version?: string | undefined;
|
|
14485
|
+
dependencies?: Record<string, string> | undefined;
|
|
14486
|
+
devDependencies?: Record<string, string> | undefined;
|
|
14487
|
+
peerDependencies?: Record<string, string> | undefined;
|
|
14488
|
+
scripts?: Record<string, string> | undefined;
|
|
12973
14489
|
}, {
|
|
12974
|
-
|
|
12975
|
-
|
|
12976
|
-
|
|
12977
|
-
|
|
12978
|
-
|
|
14490
|
+
description?: string | undefined;
|
|
14491
|
+
success?: boolean | undefined;
|
|
14492
|
+
error?: string | undefined;
|
|
14493
|
+
name?: string | undefined;
|
|
14494
|
+
version?: string | undefined;
|
|
14495
|
+
dependencies?: Record<string, string> | undefined;
|
|
14496
|
+
devDependencies?: Record<string, string> | undefined;
|
|
14497
|
+
peerDependencies?: Record<string, string> | undefined;
|
|
14498
|
+
scripts?: Record<string, string> | undefined;
|
|
14499
|
+
}>;
|
|
12979
14500
|
|
|
12980
14501
|
/**
|
|
12981
14502
|
* Package manager options
|
|
12982
14503
|
*/
|
|
12983
14504
|
export declare type PackageManager = 'npm' | 'pnpm' | 'yarn';
|
|
12984
14505
|
|
|
14506
|
+
export declare const PackageMergeInputSchema: z.ZodObject<{
|
|
14507
|
+
commitSha: z.ZodString;
|
|
14508
|
+
slug: z.ZodString;
|
|
14509
|
+
targetPath: z.ZodOptional<z.ZodString>;
|
|
14510
|
+
packageInfo: z.ZodObject<{
|
|
14511
|
+
name: z.ZodOptional<z.ZodString>;
|
|
14512
|
+
version: z.ZodOptional<z.ZodString>;
|
|
14513
|
+
description: z.ZodOptional<z.ZodString>;
|
|
14514
|
+
dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14515
|
+
devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14516
|
+
peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14517
|
+
scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
14518
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
14519
|
+
error: z.ZodOptional<z.ZodString>;
|
|
14520
|
+
}, "strip", z.ZodTypeAny, {
|
|
14521
|
+
description?: string | undefined;
|
|
14522
|
+
success?: boolean | undefined;
|
|
14523
|
+
error?: string | undefined;
|
|
14524
|
+
name?: string | undefined;
|
|
14525
|
+
version?: string | undefined;
|
|
14526
|
+
dependencies?: Record<string, string> | undefined;
|
|
14527
|
+
devDependencies?: Record<string, string> | undefined;
|
|
14528
|
+
peerDependencies?: Record<string, string> | undefined;
|
|
14529
|
+
scripts?: Record<string, string> | undefined;
|
|
14530
|
+
}, {
|
|
14531
|
+
description?: string | undefined;
|
|
14532
|
+
success?: boolean | undefined;
|
|
14533
|
+
error?: string | undefined;
|
|
14534
|
+
name?: string | undefined;
|
|
14535
|
+
version?: string | undefined;
|
|
14536
|
+
dependencies?: Record<string, string> | undefined;
|
|
14537
|
+
devDependencies?: Record<string, string> | undefined;
|
|
14538
|
+
peerDependencies?: Record<string, string> | undefined;
|
|
14539
|
+
scripts?: Record<string, string> | undefined;
|
|
14540
|
+
}>;
|
|
14541
|
+
}, "strip", z.ZodTypeAny, {
|
|
14542
|
+
slug: string;
|
|
14543
|
+
commitSha: string;
|
|
14544
|
+
packageInfo: {
|
|
14545
|
+
description?: string | undefined;
|
|
14546
|
+
success?: boolean | undefined;
|
|
14547
|
+
error?: string | undefined;
|
|
14548
|
+
name?: string | undefined;
|
|
14549
|
+
version?: string | undefined;
|
|
14550
|
+
dependencies?: Record<string, string> | undefined;
|
|
14551
|
+
devDependencies?: Record<string, string> | undefined;
|
|
14552
|
+
peerDependencies?: Record<string, string> | undefined;
|
|
14553
|
+
scripts?: Record<string, string> | undefined;
|
|
14554
|
+
};
|
|
14555
|
+
targetPath?: string | undefined;
|
|
14556
|
+
}, {
|
|
14557
|
+
slug: string;
|
|
14558
|
+
commitSha: string;
|
|
14559
|
+
packageInfo: {
|
|
14560
|
+
description?: string | undefined;
|
|
14561
|
+
success?: boolean | undefined;
|
|
14562
|
+
error?: string | undefined;
|
|
14563
|
+
name?: string | undefined;
|
|
14564
|
+
version?: string | undefined;
|
|
14565
|
+
dependencies?: Record<string, string> | undefined;
|
|
14566
|
+
devDependencies?: Record<string, string> | undefined;
|
|
14567
|
+
peerDependencies?: Record<string, string> | undefined;
|
|
14568
|
+
scripts?: Record<string, string> | undefined;
|
|
14569
|
+
};
|
|
14570
|
+
targetPath?: string | undefined;
|
|
14571
|
+
}>;
|
|
14572
|
+
|
|
14573
|
+
export declare const PackageMergeResultSchema: z.ZodObject<{
|
|
14574
|
+
success: z.ZodBoolean;
|
|
14575
|
+
applied: z.ZodBoolean;
|
|
14576
|
+
message: z.ZodString;
|
|
14577
|
+
error: z.ZodOptional<z.ZodString>;
|
|
14578
|
+
}, "strip", z.ZodTypeAny, {
|
|
14579
|
+
message: string;
|
|
14580
|
+
success: boolean;
|
|
14581
|
+
applied: boolean;
|
|
14582
|
+
error?: string | undefined;
|
|
14583
|
+
}, {
|
|
14584
|
+
message: string;
|
|
14585
|
+
success: boolean;
|
|
14586
|
+
applied: boolean;
|
|
14587
|
+
error?: string | undefined;
|
|
14588
|
+
}>;
|
|
14589
|
+
|
|
14590
|
+
export declare const PrepareBranchInputSchema: z.ZodObject<{
|
|
14591
|
+
slug: z.ZodString;
|
|
14592
|
+
commitSha: z.ZodOptional<z.ZodString>;
|
|
14593
|
+
targetPath: z.ZodOptional<z.ZodString>;
|
|
14594
|
+
}, "strip", z.ZodTypeAny, {
|
|
14595
|
+
slug: string;
|
|
14596
|
+
targetPath?: string | undefined;
|
|
14597
|
+
commitSha?: string | undefined;
|
|
14598
|
+
}, {
|
|
14599
|
+
slug: string;
|
|
14600
|
+
targetPath?: string | undefined;
|
|
14601
|
+
commitSha?: string | undefined;
|
|
14602
|
+
}>;
|
|
14603
|
+
|
|
14604
|
+
export declare const PrepareBranchResultSchema: z.ZodObject<{
|
|
14605
|
+
branchName: z.ZodString;
|
|
14606
|
+
success: z.ZodOptional<z.ZodBoolean>;
|
|
14607
|
+
error: z.ZodOptional<z.ZodString>;
|
|
14608
|
+
}, "strip", z.ZodTypeAny, {
|
|
14609
|
+
branchName: string;
|
|
14610
|
+
success?: boolean | undefined;
|
|
14611
|
+
error?: string | undefined;
|
|
14612
|
+
}, {
|
|
14613
|
+
branchName: string;
|
|
14614
|
+
success?: boolean | undefined;
|
|
14615
|
+
error?: string | undefined;
|
|
14616
|
+
}>;
|
|
14617
|
+
|
|
12985
14618
|
/**
|
|
12986
14619
|
* Project management action types
|
|
12987
14620
|
*/
|
|
@@ -12998,6 +14631,12 @@ export declare function spawn(command: string, args: string[], options: any): Pr
|
|
|
12998
14631
|
|
|
12999
14632
|
export declare function spawnSWPM(cwd: string, command: string, packageNames: string[]): Promise<void>;
|
|
13000
14633
|
|
|
14634
|
+
export declare function spawnWithOutput(command: string, args: string[], options: SpawnOptions): Promise<{
|
|
14635
|
+
stdout: string;
|
|
14636
|
+
stderr: string;
|
|
14637
|
+
code: number;
|
|
14638
|
+
}>;
|
|
14639
|
+
|
|
13001
14640
|
export declare interface TemplateManifest {
|
|
13002
14641
|
slug: string;
|
|
13003
14642
|
ref?: string;
|
|
@@ -13093,6 +14732,191 @@ export declare const UNIT_KINDS: readonly ["mcp-server", "tool", "workflow", "ag
|
|
|
13093
14732
|
|
|
13094
14733
|
export declare type UnitKind = (typeof UNIT_KINDS)[number];
|
|
13095
14734
|
|
|
14735
|
+
export declare const ValidationFixInputSchema: z.ZodObject<{
|
|
14736
|
+
commitSha: z.ZodString;
|
|
14737
|
+
slug: z.ZodString;
|
|
14738
|
+
targetPath: z.ZodOptional<z.ZodString>;
|
|
14739
|
+
templateDir: z.ZodString;
|
|
14740
|
+
orderedUnits: z.ZodArray<z.ZodObject<{
|
|
14741
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
14742
|
+
id: z.ZodString;
|
|
14743
|
+
file: z.ZodString;
|
|
14744
|
+
}, "strip", z.ZodTypeAny, {
|
|
14745
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14746
|
+
id: string;
|
|
14747
|
+
file: string;
|
|
14748
|
+
}, {
|
|
14749
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14750
|
+
id: string;
|
|
14751
|
+
file: string;
|
|
14752
|
+
}>, "many">;
|
|
14753
|
+
copiedFiles: z.ZodArray<z.ZodObject<{
|
|
14754
|
+
source: z.ZodString;
|
|
14755
|
+
destination: z.ZodString;
|
|
14756
|
+
unit: z.ZodObject<{
|
|
14757
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
14758
|
+
id: z.ZodString;
|
|
14759
|
+
}, "strip", z.ZodTypeAny, {
|
|
14760
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14761
|
+
id: string;
|
|
14762
|
+
}, {
|
|
14763
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14764
|
+
id: string;
|
|
14765
|
+
}>;
|
|
14766
|
+
}, "strip", z.ZodTypeAny, {
|
|
14767
|
+
source: string;
|
|
14768
|
+
destination: string;
|
|
14769
|
+
unit: {
|
|
14770
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14771
|
+
id: string;
|
|
14772
|
+
};
|
|
14773
|
+
}, {
|
|
14774
|
+
source: string;
|
|
14775
|
+
destination: string;
|
|
14776
|
+
unit: {
|
|
14777
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14778
|
+
id: string;
|
|
14779
|
+
};
|
|
14780
|
+
}>, "many">;
|
|
14781
|
+
conflictsResolved: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
14782
|
+
unit: z.ZodObject<{
|
|
14783
|
+
kind: z.ZodEnum<["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"]>;
|
|
14784
|
+
id: z.ZodString;
|
|
14785
|
+
}, "strip", z.ZodTypeAny, {
|
|
14786
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14787
|
+
id: string;
|
|
14788
|
+
}, {
|
|
14789
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14790
|
+
id: string;
|
|
14791
|
+
}>;
|
|
14792
|
+
issue: z.ZodString;
|
|
14793
|
+
resolution: z.ZodString;
|
|
14794
|
+
}, "strip", z.ZodTypeAny, {
|
|
14795
|
+
unit: {
|
|
14796
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14797
|
+
id: string;
|
|
14798
|
+
};
|
|
14799
|
+
issue: string;
|
|
14800
|
+
resolution: string;
|
|
14801
|
+
}, {
|
|
14802
|
+
unit: {
|
|
14803
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14804
|
+
id: string;
|
|
14805
|
+
};
|
|
14806
|
+
issue: string;
|
|
14807
|
+
resolution: string;
|
|
14808
|
+
}>, "many">>;
|
|
14809
|
+
maxIterations: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
|
|
14810
|
+
}, "strip", z.ZodTypeAny, {
|
|
14811
|
+
slug: string;
|
|
14812
|
+
commitSha: string;
|
|
14813
|
+
templateDir: string;
|
|
14814
|
+
orderedUnits: {
|
|
14815
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14816
|
+
id: string;
|
|
14817
|
+
file: string;
|
|
14818
|
+
}[];
|
|
14819
|
+
copiedFiles: {
|
|
14820
|
+
source: string;
|
|
14821
|
+
destination: string;
|
|
14822
|
+
unit: {
|
|
14823
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14824
|
+
id: string;
|
|
14825
|
+
};
|
|
14826
|
+
}[];
|
|
14827
|
+
maxIterations: number;
|
|
14828
|
+
targetPath?: string | undefined;
|
|
14829
|
+
conflictsResolved?: {
|
|
14830
|
+
unit: {
|
|
14831
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14832
|
+
id: string;
|
|
14833
|
+
};
|
|
14834
|
+
issue: string;
|
|
14835
|
+
resolution: string;
|
|
14836
|
+
}[] | undefined;
|
|
14837
|
+
}, {
|
|
14838
|
+
slug: string;
|
|
14839
|
+
commitSha: string;
|
|
14840
|
+
templateDir: string;
|
|
14841
|
+
orderedUnits: {
|
|
14842
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14843
|
+
id: string;
|
|
14844
|
+
file: string;
|
|
14845
|
+
}[];
|
|
14846
|
+
copiedFiles: {
|
|
14847
|
+
source: string;
|
|
14848
|
+
destination: string;
|
|
14849
|
+
unit: {
|
|
14850
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14851
|
+
id: string;
|
|
14852
|
+
};
|
|
14853
|
+
}[];
|
|
14854
|
+
targetPath?: string | undefined;
|
|
14855
|
+
conflictsResolved?: {
|
|
14856
|
+
unit: {
|
|
14857
|
+
kind: "integration" | "mcp-server" | "tool" | "workflow" | "agent" | "network" | "other";
|
|
14858
|
+
id: string;
|
|
14859
|
+
};
|
|
14860
|
+
issue: string;
|
|
14861
|
+
resolution: string;
|
|
14862
|
+
}[] | undefined;
|
|
14863
|
+
maxIterations?: number | undefined;
|
|
14864
|
+
}>;
|
|
14865
|
+
|
|
14866
|
+
export declare const ValidationFixResultSchema: z.ZodObject<{
|
|
14867
|
+
success: z.ZodBoolean;
|
|
14868
|
+
applied: z.ZodBoolean;
|
|
14869
|
+
message: z.ZodString;
|
|
14870
|
+
validationResults: z.ZodObject<{
|
|
14871
|
+
valid: z.ZodBoolean;
|
|
14872
|
+
errorsFixed: z.ZodNumber;
|
|
14873
|
+
remainingErrors: z.ZodNumber;
|
|
14874
|
+
}, "strip", z.ZodTypeAny, {
|
|
14875
|
+
valid: boolean;
|
|
14876
|
+
errorsFixed: number;
|
|
14877
|
+
remainingErrors: number;
|
|
14878
|
+
}, {
|
|
14879
|
+
valid: boolean;
|
|
14880
|
+
errorsFixed: number;
|
|
14881
|
+
remainingErrors: number;
|
|
14882
|
+
}>;
|
|
14883
|
+
error: z.ZodOptional<z.ZodString>;
|
|
14884
|
+
}, "strip", z.ZodTypeAny, {
|
|
14885
|
+
message: string;
|
|
14886
|
+
success: boolean;
|
|
14887
|
+
applied: boolean;
|
|
14888
|
+
validationResults: {
|
|
14889
|
+
valid: boolean;
|
|
14890
|
+
errorsFixed: number;
|
|
14891
|
+
remainingErrors: number;
|
|
14892
|
+
};
|
|
14893
|
+
error?: string | undefined;
|
|
14894
|
+
}, {
|
|
14895
|
+
message: string;
|
|
14896
|
+
success: boolean;
|
|
14897
|
+
applied: boolean;
|
|
14898
|
+
validationResults: {
|
|
14899
|
+
valid: boolean;
|
|
14900
|
+
errorsFixed: number;
|
|
14901
|
+
remainingErrors: number;
|
|
14902
|
+
};
|
|
14903
|
+
error?: string | undefined;
|
|
14904
|
+
}>;
|
|
14905
|
+
|
|
14906
|
+
export declare const ValidationResultsSchema: z.ZodObject<{
|
|
14907
|
+
valid: z.ZodBoolean;
|
|
14908
|
+
errorsFixed: z.ZodNumber;
|
|
14909
|
+
remainingErrors: z.ZodNumber;
|
|
14910
|
+
}, "strip", z.ZodTypeAny, {
|
|
14911
|
+
valid: boolean;
|
|
14912
|
+
errorsFixed: number;
|
|
14913
|
+
remainingErrors: number;
|
|
14914
|
+
}, {
|
|
14915
|
+
valid: boolean;
|
|
14916
|
+
errorsFixed: number;
|
|
14917
|
+
remainingErrors: number;
|
|
14918
|
+
}>;
|
|
14919
|
+
|
|
13096
14920
|
/**
|
|
13097
14921
|
* Validation types for code validation
|
|
13098
14922
|
*/
|