@maycombhq/sdk 2.0.0-beta.1 → 2.0.0-beta.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/{dist → npm}/cache.d.ts +1 -1
- package/npm/core/api.d.ts +7462 -0
- package/npm/core/assistant-actor.d.ts +15 -0
- package/npm/core/audit.d.ts +153 -0
- package/npm/core/branches.d.ts +21 -0
- package/npm/core/cancel.d.ts +9 -0
- package/npm/core/catalog.d.ts +4733 -0
- package/npm/core/change-types-migrate.d.ts +10 -0
- package/npm/core/cite.d.ts +54 -0
- package/npm/core/curated.d.ts +37 -0
- package/npm/core/fact-paths.d.ts +14 -0
- package/npm/core/facts-callers.d.ts +152 -0
- package/npm/core/facts-carry.d.ts +36 -0
- package/npm/core/facts-join-prototype.d.ts +234 -0
- package/npm/core/facts-join-vendor.d.ts +110 -0
- package/npm/core/facts-join.d.ts +482 -0
- package/npm/core/facts.d.ts +94 -0
- package/npm/core/fs.d.ts +47 -0
- package/npm/core/gates-migrate.d.ts +10 -0
- package/npm/core/host-questions.d.ts +66 -0
- package/npm/core/identity.d.ts +17 -0
- package/npm/core/index.d.ts +73 -0
- package/npm/core/json-schema.d.ts +20 -0
- package/npm/core/judgments.d.ts +63 -0
- package/npm/core/light.d.ts +8 -0
- package/npm/core/link-evidence.d.ts +212 -0
- package/npm/core/log.d.ts +49 -0
- package/npm/core/manifest-edit.d.ts +57 -0
- package/npm/core/merge.d.ts +78 -0
- package/npm/core/metarepo.d.ts +91 -0
- package/npm/core/migrate.d.ts +31 -0
- package/npm/core/migration-files.d.ts +13 -0
- package/npm/core/orgpack-defaults.d.ts +199 -0
- package/npm/core/orgpack-load.d.ts +102 -0
- package/npm/core/question-order.d.ts +23 -0
- package/npm/core/question-owners.d.ts +53 -0
- package/npm/core/question-proposals.d.ts +77 -0
- package/npm/core/questions.d.ts +297 -0
- package/npm/core/record-cache.d.ts +52 -0
- package/npm/core/refs.d.ts +9 -0
- package/npm/core/repo-description.d.ts +44 -0
- package/npm/core/repo-reads.d.ts +44 -0
- package/npm/core/roles-migrate.d.ts +9 -0
- package/npm/core/runtime-migrate.d.ts +11 -0
- package/npm/core/schema/ai.d.ts +397 -0
- package/npm/core/schema/change.d.ts +244 -0
- package/npm/core/schema/common.d.ts +135 -0
- package/npm/core/schema/conventions.d.ts +75 -0
- package/npm/core/schema/dialect.d.ts +801 -0
- package/npm/core/schema/executors.d.ts +396 -0
- package/npm/core/schema/fact-corrections.d.ts +55 -0
- package/npm/core/schema/facts.d.ts +1491 -0
- package/npm/core/schema/frameworks.d.ts +371 -0
- package/npm/core/schema/judgment.d.ts +77 -0
- package/npm/core/schema/kinds.d.ts +5166 -0
- package/npm/core/schema/layout.d.ts +25 -0
- package/npm/core/schema/orgpack.d.ts +1185 -0
- package/npm/core/schema/plugin.d.ts +73 -0
- package/npm/core/schema/question.d.ts +195 -0
- package/npm/core/schema/repo-type.d.ts +109 -0
- package/npm/core/schema/review.d.ts +558 -0
- package/npm/core/schema/scan-settings.d.ts +34 -0
- package/npm/core/schema/scan-verify.d.ts +535 -0
- package/npm/core/schema/spec.d.ts +269 -0
- package/npm/core/schema/version.d.ts +9 -0
- package/npm/core/schema/workspace.d.ts +330 -0
- package/npm/core/serialize.d.ts +17 -0
- package/npm/core/shared-maps.d.ts +146 -0
- package/npm/core/sources-migrate.d.ts +15 -0
- package/npm/core/specs.d.ts +66 -0
- package/npm/core/stack-helpers.d.ts +32 -0
- package/npm/core/tar-read.d.ts +13 -0
- package/npm/core/template.d.ts +101 -0
- package/npm/core/words.d.ts +13 -0
- package/npm/core/zip-read.d.ts +37 -0
- package/npm/core/zip.d.ts +13 -0
- package/npm/index.js +9780 -0
- package/{dist → npm}/plugin.d.ts +1 -1
- package/{dist → npm}/runner.d.ts +1 -1
- package/package.json +10 -11
- package/dist/cache.js +0 -115
- package/dist/cache.js.map +0 -1
- package/dist/fs-repo.js +0 -120
- package/dist/fs-repo.js.map +0 -1
- package/dist/index.js +0 -7
- package/dist/index.js.map +0 -1
- package/dist/parse-cache.js +0 -275
- package/dist/parse-cache.js.map +0 -1
- package/dist/plugin.js +0 -85
- package/dist/plugin.js.map +0 -1
- package/dist/runner.js +0 -209
- package/dist/runner.js.map +0 -1
- package/dist/sandbox.js +0 -443
- package/dist/sandbox.js.map +0 -1
- /package/{dist → npm}/fs-repo.d.ts +0 -0
- /package/{dist → npm}/index.d.ts +0 -0
- /package/{dist → npm}/parse-cache.d.ts +0 -0
- /package/{dist → npm}/sandbox.d.ts +0 -0
|
@@ -0,0 +1,1185 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
/**
|
|
3
|
+
* Contract C6: org-pack schemas. Everything about how an organisation, platform or team
|
|
4
|
+
* works is a file in org-pack/, validated against these schemas and changed through PRs.
|
|
5
|
+
* Every file is optional: built-in defaults apply until a team writes its own. See ADR 0012.
|
|
6
|
+
*/
|
|
7
|
+
export declare const ORGPACK_SCHEMA_VERSION: 1;
|
|
8
|
+
export declare const PackManifest: z.ZodObject<{
|
|
9
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
10
|
+
name: z.ZodString;
|
|
11
|
+
version: z.ZodString;
|
|
12
|
+
owner: z.ZodString;
|
|
13
|
+
reviewWindowDays: z.ZodDefault<z.ZodNumber>;
|
|
14
|
+
freshness: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
|
|
15
|
+
System: "System";
|
|
16
|
+
Component: "Component";
|
|
17
|
+
Endpoint: "Endpoint";
|
|
18
|
+
Interface: "Interface";
|
|
19
|
+
GatewayRoute: "GatewayRoute";
|
|
20
|
+
Schema: "Schema";
|
|
21
|
+
FieldMapping: "FieldMapping";
|
|
22
|
+
DataStore: "DataStore";
|
|
23
|
+
Table: "Table";
|
|
24
|
+
Column: "Column";
|
|
25
|
+
IndexConstraint: "IndexConstraint";
|
|
26
|
+
Migration: "Migration";
|
|
27
|
+
Deployment: "Deployment";
|
|
28
|
+
Setting: "Setting";
|
|
29
|
+
ObservabilityAsset: "ObservabilityAsset";
|
|
30
|
+
AccessGrant: "AccessGrant";
|
|
31
|
+
QualityAsset: "QualityAsset";
|
|
32
|
+
Obligation: "Obligation";
|
|
33
|
+
GlossaryTerm: "GlossaryTerm";
|
|
34
|
+
Pattern: "Pattern";
|
|
35
|
+
Decision: "Decision";
|
|
36
|
+
SourceDocument: "SourceDocument";
|
|
37
|
+
Party: "Party";
|
|
38
|
+
Product: "Product";
|
|
39
|
+
Initiative: "Initiative";
|
|
40
|
+
Commitment: "Commitment";
|
|
41
|
+
OwnerQuestion: "OwnerQuestion";
|
|
42
|
+
ProcessDefinition: "ProcessDefinition";
|
|
43
|
+
ProcessArtifact: "ProcessArtifact";
|
|
44
|
+
Capability: "Capability";
|
|
45
|
+
Flow: "Flow";
|
|
46
|
+
Unresolved: "Unresolved";
|
|
47
|
+
CuratedDecision: "CuratedDecision";
|
|
48
|
+
}> & z.core.$partial, z.ZodNumber>>;
|
|
49
|
+
classification: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
50
|
+
}, z.core.$strict>;
|
|
51
|
+
export type PackManifest = z.infer<typeof PackManifest>;
|
|
52
|
+
/**
|
|
53
|
+
* roles.yaml is deprecated (ADR 0073): Atticus has no roles, views or in-app approvals. The
|
|
54
|
+
* person is the metarepo's Git user and a gate is approved when its hand-off PR merges. A pack
|
|
55
|
+
* that still has roles.yaml loads and validates as before; nothing reads it. The role ids stay
|
|
56
|
+
* because change-types.yaml and gates.yaml still name them (also no longer read for approvals).
|
|
57
|
+
*/
|
|
58
|
+
export declare const CORE_ROLES: readonly ["product-owner", "business-analyst", "architect", "team-lead", "developer", "qa", "delivery-lead", "platform-lead", "designer"];
|
|
59
|
+
export declare const OPTIONAL_ROLES: readonly ["process-owner", "data-architect", "sre", "security-reviewer"];
|
|
60
|
+
export declare const BUILT_IN_ROLES: readonly ["product-owner", "business-analyst", "architect", "team-lead", "developer", "qa", "delivery-lead", "platform-lead", "designer", "process-owner", "data-architect", "sre", "security-reviewer"];
|
|
61
|
+
/** Deprecated with roles.yaml (ADR 0073): these actions are metarepo files or adapter writes now. */
|
|
62
|
+
export declare const NonGitAction: z.ZodEnum<{
|
|
63
|
+
"release-go-no-go": "release-go-no-go";
|
|
64
|
+
waiver: "waiver";
|
|
65
|
+
"snow-submission": "snow-submission";
|
|
66
|
+
"org-pack-change": "org-pack-change";
|
|
67
|
+
"catalog-assert": "catalog-assert";
|
|
68
|
+
}>;
|
|
69
|
+
export declare const Approver: z.ZodObject<{
|
|
70
|
+
roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
71
|
+
groups: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
72
|
+
people: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
73
|
+
}, z.core.$strict>;
|
|
74
|
+
/**
|
|
75
|
+
* roles.yaml version 2 (ADR 0140) adds `teams`: who is on each team a repo manifest's `owner`
|
|
76
|
+
* names, so a question goes to the team that owns its repo and a person can list their own.
|
|
77
|
+
* Words, not permissions: nothing is allowed or refused by team. The rest of the file stays
|
|
78
|
+
* deprecated (ADR 0073). A version-1 file is read as it is; `teams` needs version 2.
|
|
79
|
+
*/
|
|
80
|
+
export declare const ROLES_SCHEMA_VERSION: 2;
|
|
81
|
+
export declare const Team: z.ZodObject<{
|
|
82
|
+
id: z.ZodString;
|
|
83
|
+
name: z.ZodOptional<z.ZodString>;
|
|
84
|
+
people: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
85
|
+
}, z.core.$strict>;
|
|
86
|
+
export type Team = z.infer<typeof Team>;
|
|
87
|
+
export declare const Roles: z.ZodObject<{
|
|
88
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
89
|
+
teams: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
90
|
+
id: z.ZodString;
|
|
91
|
+
name: z.ZodOptional<z.ZodString>;
|
|
92
|
+
people: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
93
|
+
}, z.core.$strict>>>;
|
|
94
|
+
custom: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
95
|
+
id: z.ZodString;
|
|
96
|
+
name: z.ZodString;
|
|
97
|
+
basedOn: z.ZodEnum<{
|
|
98
|
+
"product-owner": "product-owner";
|
|
99
|
+
"business-analyst": "business-analyst";
|
|
100
|
+
architect: "architect";
|
|
101
|
+
"team-lead": "team-lead";
|
|
102
|
+
developer: "developer";
|
|
103
|
+
qa: "qa";
|
|
104
|
+
"delivery-lead": "delivery-lead";
|
|
105
|
+
"platform-lead": "platform-lead";
|
|
106
|
+
designer: "designer";
|
|
107
|
+
"process-owner": "process-owner";
|
|
108
|
+
"data-architect": "data-architect";
|
|
109
|
+
sre: "sre";
|
|
110
|
+
"security-reviewer": "security-reviewer";
|
|
111
|
+
}>;
|
|
112
|
+
}, z.core.$strict>>>;
|
|
113
|
+
enabledOptional: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
114
|
+
"process-owner": "process-owner";
|
|
115
|
+
"data-architect": "data-architect";
|
|
116
|
+
sre: "sre";
|
|
117
|
+
"security-reviewer": "security-reviewer";
|
|
118
|
+
}>>>;
|
|
119
|
+
mappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
120
|
+
group: z.ZodString;
|
|
121
|
+
role: z.ZodString;
|
|
122
|
+
}, z.core.$strict>>>;
|
|
123
|
+
approvals: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
|
|
124
|
+
"release-go-no-go": "release-go-no-go";
|
|
125
|
+
waiver: "waiver";
|
|
126
|
+
"snow-submission": "snow-submission";
|
|
127
|
+
"org-pack-change": "org-pack-change";
|
|
128
|
+
"catalog-assert": "catalog-assert";
|
|
129
|
+
}> & z.core.$partial, z.ZodObject<{
|
|
130
|
+
roles: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
131
|
+
groups: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
132
|
+
people: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
133
|
+
}, z.core.$strict>>>;
|
|
134
|
+
separation: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
135
|
+
actions: z.ZodTuple<[z.ZodString, z.ZodString], null>;
|
|
136
|
+
reason: z.ZodString;
|
|
137
|
+
}, z.core.$strict>>>;
|
|
138
|
+
}, z.core.$strict>;
|
|
139
|
+
export type Roles = z.infer<typeof Roles>;
|
|
140
|
+
export declare const PHASES: readonly ["define", "design", "plan", "build", "qa", "release"];
|
|
141
|
+
export declare const Phase: z.ZodEnum<{
|
|
142
|
+
release: "release";
|
|
143
|
+
design: "design";
|
|
144
|
+
qa: "qa";
|
|
145
|
+
define: "define";
|
|
146
|
+
plan: "plan";
|
|
147
|
+
build: "build";
|
|
148
|
+
}>;
|
|
149
|
+
/** Artifacts of the org-flow schema plus Atticus's own change files. */
|
|
150
|
+
export declare const ChangeArtifact: z.ZodEnum<{
|
|
151
|
+
interfaces: "interfaces";
|
|
152
|
+
data: "data";
|
|
153
|
+
ux: "ux";
|
|
154
|
+
brief: "brief";
|
|
155
|
+
proposal: "proposal";
|
|
156
|
+
specs: "specs";
|
|
157
|
+
mappings: "mappings";
|
|
158
|
+
design: "design";
|
|
159
|
+
stories: "stories";
|
|
160
|
+
tasks: "tasks";
|
|
161
|
+
snow: "snow";
|
|
162
|
+
}>;
|
|
163
|
+
export declare const ChangeType: z.ZodObject<{
|
|
164
|
+
id: z.ZodString;
|
|
165
|
+
name: z.ZodString;
|
|
166
|
+
description: z.ZodOptional<z.ZodString>;
|
|
167
|
+
phases: z.ZodArray<z.ZodEnum<{
|
|
168
|
+
release: "release";
|
|
169
|
+
design: "design";
|
|
170
|
+
qa: "qa";
|
|
171
|
+
define: "define";
|
|
172
|
+
plan: "plan";
|
|
173
|
+
build: "build";
|
|
174
|
+
}>>;
|
|
175
|
+
artifacts: z.ZodArray<z.ZodEnum<{
|
|
176
|
+
interfaces: "interfaces";
|
|
177
|
+
data: "data";
|
|
178
|
+
ux: "ux";
|
|
179
|
+
brief: "brief";
|
|
180
|
+
proposal: "proposal";
|
|
181
|
+
specs: "specs";
|
|
182
|
+
mappings: "mappings";
|
|
183
|
+
design: "design";
|
|
184
|
+
stories: "stories";
|
|
185
|
+
tasks: "tasks";
|
|
186
|
+
snow: "snow";
|
|
187
|
+
}>>;
|
|
188
|
+
lenses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
189
|
+
true: "true";
|
|
190
|
+
complete: "complete";
|
|
191
|
+
safe: "safe";
|
|
192
|
+
ship: "ship";
|
|
193
|
+
business: "business";
|
|
194
|
+
architecture: "architecture";
|
|
195
|
+
story: "story";
|
|
196
|
+
ux: "ux";
|
|
197
|
+
delivery: "delivery";
|
|
198
|
+
"code-and-test": "code-and-test";
|
|
199
|
+
release: "release";
|
|
200
|
+
}>>>;
|
|
201
|
+
approvals: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
|
|
202
|
+
release: "release";
|
|
203
|
+
design: "design";
|
|
204
|
+
qa: "qa";
|
|
205
|
+
define: "define";
|
|
206
|
+
plan: "plan";
|
|
207
|
+
build: "build";
|
|
208
|
+
}> & z.core.$partial, z.ZodArray<z.ZodString>>>;
|
|
209
|
+
postReleaseReview: z.ZodDefault<z.ZodBoolean>;
|
|
210
|
+
size: z.ZodOptional<z.ZodEnum<{
|
|
211
|
+
small: "small";
|
|
212
|
+
standard: "standard";
|
|
213
|
+
}>>;
|
|
214
|
+
smallWhenBriefSays: z.ZodOptional<z.ZodBoolean>;
|
|
215
|
+
fastGate: z.ZodOptional<z.ZodString>;
|
|
216
|
+
}, z.core.$strict>;
|
|
217
|
+
export type ChangeType = z.infer<typeof ChangeType>;
|
|
218
|
+
/**
|
|
219
|
+
* change-types.yaml's own schema version (ADR 0113). Version 2 adds a type's size, whether a
|
|
220
|
+
* brief may say it is small, and the fast path's gate. Version 1 files still read, every type
|
|
221
|
+
* standard; `atticus upgrade` moves them to version 2 (`change-types-v2`), changing nothing else.
|
|
222
|
+
*/
|
|
223
|
+
export declare const CHANGE_TYPES_SCHEMA_VERSION: 2;
|
|
224
|
+
export declare const ChangeTypes: z.ZodObject<{
|
|
225
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
226
|
+
types: z.ZodArray<z.ZodObject<{
|
|
227
|
+
id: z.ZodString;
|
|
228
|
+
name: z.ZodString;
|
|
229
|
+
description: z.ZodOptional<z.ZodString>;
|
|
230
|
+
phases: z.ZodArray<z.ZodEnum<{
|
|
231
|
+
release: "release";
|
|
232
|
+
design: "design";
|
|
233
|
+
qa: "qa";
|
|
234
|
+
define: "define";
|
|
235
|
+
plan: "plan";
|
|
236
|
+
build: "build";
|
|
237
|
+
}>>;
|
|
238
|
+
artifacts: z.ZodArray<z.ZodEnum<{
|
|
239
|
+
interfaces: "interfaces";
|
|
240
|
+
data: "data";
|
|
241
|
+
ux: "ux";
|
|
242
|
+
brief: "brief";
|
|
243
|
+
proposal: "proposal";
|
|
244
|
+
specs: "specs";
|
|
245
|
+
mappings: "mappings";
|
|
246
|
+
design: "design";
|
|
247
|
+
stories: "stories";
|
|
248
|
+
tasks: "tasks";
|
|
249
|
+
snow: "snow";
|
|
250
|
+
}>>;
|
|
251
|
+
lenses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
252
|
+
true: "true";
|
|
253
|
+
complete: "complete";
|
|
254
|
+
safe: "safe";
|
|
255
|
+
ship: "ship";
|
|
256
|
+
business: "business";
|
|
257
|
+
architecture: "architecture";
|
|
258
|
+
story: "story";
|
|
259
|
+
ux: "ux";
|
|
260
|
+
delivery: "delivery";
|
|
261
|
+
"code-and-test": "code-and-test";
|
|
262
|
+
release: "release";
|
|
263
|
+
}>>>;
|
|
264
|
+
approvals: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
|
|
265
|
+
release: "release";
|
|
266
|
+
design: "design";
|
|
267
|
+
qa: "qa";
|
|
268
|
+
define: "define";
|
|
269
|
+
plan: "plan";
|
|
270
|
+
build: "build";
|
|
271
|
+
}> & z.core.$partial, z.ZodArray<z.ZodString>>>;
|
|
272
|
+
postReleaseReview: z.ZodDefault<z.ZodBoolean>;
|
|
273
|
+
size: z.ZodOptional<z.ZodEnum<{
|
|
274
|
+
small: "small";
|
|
275
|
+
standard: "standard";
|
|
276
|
+
}>>;
|
|
277
|
+
smallWhenBriefSays: z.ZodOptional<z.ZodBoolean>;
|
|
278
|
+
fastGate: z.ZodOptional<z.ZodString>;
|
|
279
|
+
}, z.core.$strict>>;
|
|
280
|
+
}, z.core.$strict>;
|
|
281
|
+
/**
|
|
282
|
+
* The size a brief states (ADR 0113): a line "Size: small" or "Size: standard" (bold, quoted or
|
|
283
|
+
* in a list is fine), or `size:` in its front matter. Comments are left out, so a template's
|
|
284
|
+
* own hint never counts. Undefined when the brief says nothing.
|
|
285
|
+
*/
|
|
286
|
+
export declare function briefSize(brief: string): "small" | "standard" | undefined;
|
|
287
|
+
/**
|
|
288
|
+
* Whether a change of this type, with this brief, takes the fast path (ADR 0113), and why: its
|
|
289
|
+
* type is small (unless its brief says standard), or its brief says small and the type allows
|
|
290
|
+
* that. A brief can always ask for the full path; it can ask for the fast one only where the
|
|
291
|
+
* org pack lets it.
|
|
292
|
+
*/
|
|
293
|
+
export declare function fastPathOf(type: {
|
|
294
|
+
size?: "standard" | "small" | undefined;
|
|
295
|
+
smallWhenBriefSays?: boolean | undefined;
|
|
296
|
+
}, brief?: string): {
|
|
297
|
+
fast: boolean;
|
|
298
|
+
why: "type" | "brief" | "brief-standard" | "brief-not-allowed" | "standard";
|
|
299
|
+
};
|
|
300
|
+
/**
|
|
301
|
+
* The gate whose critic reviews the fast path's step (ADR 0113): the type's fastGate, else the
|
|
302
|
+
* first gate of its last phase before build, else of its first phase. Undefined when gates.yaml
|
|
303
|
+
* has no gate on that phase.
|
|
304
|
+
*/
|
|
305
|
+
export declare function fastGateOf(type: {
|
|
306
|
+
phases: readonly string[];
|
|
307
|
+
fastGate?: string | undefined;
|
|
308
|
+
}, gates: {
|
|
309
|
+
gates: {
|
|
310
|
+
id: string;
|
|
311
|
+
phase: string;
|
|
312
|
+
}[];
|
|
313
|
+
}): string | undefined;
|
|
314
|
+
export declare const Gate: z.ZodObject<{
|
|
315
|
+
id: z.ZodString;
|
|
316
|
+
phase: z.ZodEnum<{
|
|
317
|
+
release: "release";
|
|
318
|
+
design: "design";
|
|
319
|
+
qa: "qa";
|
|
320
|
+
define: "define";
|
|
321
|
+
plan: "plan";
|
|
322
|
+
build: "build";
|
|
323
|
+
}>;
|
|
324
|
+
approvers: z.ZodArray<z.ZodString>;
|
|
325
|
+
minApprovals: z.ZodDefault<z.ZodNumber>;
|
|
326
|
+
checklists: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
327
|
+
checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
328
|
+
check: z.ZodString;
|
|
329
|
+
params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
330
|
+
}, z.core.$strict>>>;
|
|
331
|
+
maxAuthorRounds: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
|
|
332
|
+
}, z.core.$strict>;
|
|
333
|
+
/**
|
|
334
|
+
* gates.yaml's own schema version (ADR 0087). Version 2 makes a gate with no maxAuthorRounds
|
|
335
|
+
* unlimited (plan principle 4: loops end by the fingerprint rule, not by a count). Version 1
|
|
336
|
+
* files still read, with their old default of two rounds; `atticus upgrade` migrates them.
|
|
337
|
+
*/
|
|
338
|
+
export declare const GATES_SCHEMA_VERSION: 2;
|
|
339
|
+
export declare const Gates: z.ZodObject<{
|
|
340
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
341
|
+
gates: z.ZodArray<z.ZodObject<{
|
|
342
|
+
id: z.ZodString;
|
|
343
|
+
phase: z.ZodEnum<{
|
|
344
|
+
release: "release";
|
|
345
|
+
design: "design";
|
|
346
|
+
qa: "qa";
|
|
347
|
+
define: "define";
|
|
348
|
+
plan: "plan";
|
|
349
|
+
build: "build";
|
|
350
|
+
}>;
|
|
351
|
+
approvers: z.ZodArray<z.ZodString>;
|
|
352
|
+
minApprovals: z.ZodDefault<z.ZodNumber>;
|
|
353
|
+
checklists: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
354
|
+
checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
355
|
+
check: z.ZodString;
|
|
356
|
+
params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
357
|
+
}, z.core.$strict>>>;
|
|
358
|
+
maxAuthorRounds: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unlimited">]>>;
|
|
359
|
+
}, z.core.$strict>>;
|
|
360
|
+
}, z.core.$strict>;
|
|
361
|
+
/** A gate's critic round limit, or undefined when there is none (ADR 0087). */
|
|
362
|
+
export declare function gateRoundLimit(gates: {
|
|
363
|
+
schemaVersion: number;
|
|
364
|
+
gates: {
|
|
365
|
+
id: string;
|
|
366
|
+
maxAuthorRounds?: number | "unlimited";
|
|
367
|
+
}[];
|
|
368
|
+
}, gate: string): number | undefined;
|
|
369
|
+
export declare const PatternCode: z.ZodString;
|
|
370
|
+
export declare const IntegrationPattern: z.ZodObject<{
|
|
371
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
372
|
+
code: z.ZodString;
|
|
373
|
+
name: z.ZodString;
|
|
374
|
+
definition: z.ZodString;
|
|
375
|
+
interaction: z.ZodEnum<{
|
|
376
|
+
sync: "sync";
|
|
377
|
+
async: "async";
|
|
378
|
+
"data-access": "data-access";
|
|
379
|
+
}>;
|
|
380
|
+
route: z.ZodEnum<{
|
|
381
|
+
gateway: "gateway";
|
|
382
|
+
other: "other";
|
|
383
|
+
direct: "direct";
|
|
384
|
+
"event-bus": "event-bus";
|
|
385
|
+
pubsub: "pubsub";
|
|
386
|
+
sftp: "sftp";
|
|
387
|
+
mq: "mq";
|
|
388
|
+
jdbc: "jdbc";
|
|
389
|
+
}>;
|
|
390
|
+
targetType: z.ZodEnum<{
|
|
391
|
+
product: "product";
|
|
392
|
+
internal: "internal";
|
|
393
|
+
vendor: "vendor";
|
|
394
|
+
"data-store": "data-store";
|
|
395
|
+
}>;
|
|
396
|
+
controls: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
397
|
+
resilience: z.ZodDefault<z.ZodObject<{
|
|
398
|
+
timeoutMs: z.ZodOptional<z.ZodNumber>;
|
|
399
|
+
retries: z.ZodOptional<z.ZodNumber>;
|
|
400
|
+
circuitBreaker: z.ZodOptional<z.ZodBoolean>;
|
|
401
|
+
}, z.core.$strict>>;
|
|
402
|
+
technology: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
403
|
+
detection: z.ZodDefault<z.ZodObject<{
|
|
404
|
+
via: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
405
|
+
gateway: "gateway";
|
|
406
|
+
other: "other";
|
|
407
|
+
direct: "direct";
|
|
408
|
+
"event-bus": "event-bus";
|
|
409
|
+
pubsub: "pubsub";
|
|
410
|
+
sftp: "sftp";
|
|
411
|
+
mq: "mq";
|
|
412
|
+
}>>>;
|
|
413
|
+
sync: z.ZodOptional<z.ZodEnum<{
|
|
414
|
+
sync: "sync";
|
|
415
|
+
async: "async";
|
|
416
|
+
}>>;
|
|
417
|
+
targetBoundary: z.ZodOptional<z.ZodEnum<{
|
|
418
|
+
product: "product";
|
|
419
|
+
internal: "internal";
|
|
420
|
+
vendor: "vendor";
|
|
421
|
+
}>>;
|
|
422
|
+
sameSystem: z.ZodOptional<z.ZodBoolean>;
|
|
423
|
+
hints: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
424
|
+
}, z.core.$strict>>;
|
|
425
|
+
checklist: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
426
|
+
source: z.ZodString;
|
|
427
|
+
version: z.ZodString;
|
|
428
|
+
status: z.ZodEnum<{
|
|
429
|
+
deprecated: "deprecated";
|
|
430
|
+
confirmed: "confirmed";
|
|
431
|
+
"to-review": "to-review";
|
|
432
|
+
}>;
|
|
433
|
+
}, z.core.$strict>;
|
|
434
|
+
export type IntegrationPattern = z.infer<typeof IntegrationPattern>;
|
|
435
|
+
/** Suggested source kinds (ADR 0083). Tags are free text: an organisation adds its own. */
|
|
436
|
+
export declare const SOURCE_KIND_SUGGESTIONS: readonly ["enterprise-architecture", "integration-patterns", "platform-runbook", "security-standard", "change-process", "framework"];
|
|
437
|
+
/**
|
|
438
|
+
* Tags on a knowledge source (ADR 0083): the kinds of knowledge it holds and the frameworks it
|
|
439
|
+
* is about. The source's owner is its `owner` field. Free text, lowercase slugs.
|
|
440
|
+
*/
|
|
441
|
+
export declare const SourceTags: z.ZodObject<{
|
|
442
|
+
kinds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
443
|
+
frameworks: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
444
|
+
}, z.core.$strict>;
|
|
445
|
+
export type SourceTags = z.infer<typeof SourceTags>;
|
|
446
|
+
/**
|
|
447
|
+
* sources.yaml's own schema version. Version 2 (ADR 0127) adds a wiki's `include` and `exclude`
|
|
448
|
+
* globs. Version 3 (ADR 0132) adds what a source's word counts for (`authority`, `byPage`,
|
|
449
|
+
* `reviewMonths`), where it applies (`appliesTo`), `readRestricted`, `maxPages`, and the
|
|
450
|
+
* `confluence-export` and `sharepoint-export` folder types. Version 1 and 2 files still read;
|
|
451
|
+
* `atticus upgrade` moves them up (`sources-v2`, `sources-v3`), changing nothing else.
|
|
452
|
+
*/
|
|
453
|
+
export declare const SOURCES_SCHEMA_VERSION: 3;
|
|
454
|
+
/**
|
|
455
|
+
* How much a source's word counts (ADR 0132), most first: the organisation's own rules
|
|
456
|
+
* (enterprise architecture, security), a shared platform team's guidance, a framework's own
|
|
457
|
+
* documentation, a team's pages, and reference material (a glossary, notes). A source without
|
|
458
|
+
* one ranks as a team's. Authority decides only between pages on the same topic: never relevance.
|
|
459
|
+
*/
|
|
460
|
+
export declare const SOURCE_AUTHORITIES: readonly ["standard", "platform", "framework", "team", "reference"];
|
|
461
|
+
export type SourceAuthority = (typeof SOURCE_AUTHORITIES)[number];
|
|
462
|
+
/** A page's status (ADR 0132): a page that is no longer current ranks below every current one. */
|
|
463
|
+
export declare const PAGE_STATUSES: readonly ["current", "deprecated", "superseded", "archived"];
|
|
464
|
+
export type PageStatus = (typeof PAGE_STATUSES)[number];
|
|
465
|
+
/** Where a source applies (ADR 0132): a page attaches to a task whose places fall in it. */
|
|
466
|
+
export declare const SourceScope: z.ZodObject<{
|
|
467
|
+
systems: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
468
|
+
components: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
469
|
+
platforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
470
|
+
repoTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
471
|
+
frameworks: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
472
|
+
newComponents: z.ZodOptional<z.ZodBoolean>;
|
|
473
|
+
}, z.core.$strict>;
|
|
474
|
+
export type SourceScope = z.infer<typeof SourceScope>;
|
|
475
|
+
export declare const Sources: z.ZodObject<{
|
|
476
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
|
|
477
|
+
layout: z.ZodDefault<z.ZodObject<{
|
|
478
|
+
openspec: z.ZodDefault<z.ZodString>;
|
|
479
|
+
catalog: z.ZodDefault<z.ZodString>;
|
|
480
|
+
constitution: z.ZodOptional<z.ZodString>;
|
|
481
|
+
skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
482
|
+
prompts: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
483
|
+
}, z.core.$strict>>;
|
|
484
|
+
wikis: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
|
|
485
|
+
id: z.ZodString;
|
|
486
|
+
type: z.ZodEnum<{
|
|
487
|
+
"confluence-export": "confluence-export";
|
|
488
|
+
"sharepoint-export": "sharepoint-export";
|
|
489
|
+
confluence: "confluence";
|
|
490
|
+
"ado-wiki": "ado-wiki";
|
|
491
|
+
sharepoint: "sharepoint";
|
|
492
|
+
"markdown-folder": "markdown-folder";
|
|
493
|
+
git: "git";
|
|
494
|
+
}>;
|
|
495
|
+
location: z.ZodString;
|
|
496
|
+
spaces: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
497
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
498
|
+
tags: z.ZodOptional<z.ZodObject<{
|
|
499
|
+
kinds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
500
|
+
frameworks: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
501
|
+
}, z.core.$strict>>;
|
|
502
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
503
|
+
path: z.ZodOptional<z.ZodString>;
|
|
504
|
+
checkout: z.ZodOptional<z.ZodEnum<{
|
|
505
|
+
clone: "clone";
|
|
506
|
+
submodule: "submodule";
|
|
507
|
+
}>>;
|
|
508
|
+
include: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
509
|
+
exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
510
|
+
authority: z.ZodOptional<z.ZodEnum<{
|
|
511
|
+
platform: "platform";
|
|
512
|
+
standard: "standard";
|
|
513
|
+
framework: "framework";
|
|
514
|
+
team: "team";
|
|
515
|
+
reference: "reference";
|
|
516
|
+
}>>;
|
|
517
|
+
byPage: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
518
|
+
match: z.ZodArray<z.ZodString>;
|
|
519
|
+
authority: z.ZodOptional<z.ZodEnum<{
|
|
520
|
+
platform: "platform";
|
|
521
|
+
standard: "standard";
|
|
522
|
+
framework: "framework";
|
|
523
|
+
team: "team";
|
|
524
|
+
reference: "reference";
|
|
525
|
+
}>>;
|
|
526
|
+
status: z.ZodOptional<z.ZodEnum<{
|
|
527
|
+
current: "current";
|
|
528
|
+
deprecated: "deprecated";
|
|
529
|
+
superseded: "superseded";
|
|
530
|
+
archived: "archived";
|
|
531
|
+
}>>;
|
|
532
|
+
}, z.core.$strict>>>;
|
|
533
|
+
reviewMonths: z.ZodOptional<z.ZodNumber>;
|
|
534
|
+
appliesTo: z.ZodOptional<z.ZodObject<{
|
|
535
|
+
systems: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
536
|
+
components: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
537
|
+
platforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
538
|
+
repoTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
539
|
+
frameworks: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
540
|
+
newComponents: z.ZodOptional<z.ZodBoolean>;
|
|
541
|
+
}, z.core.$strict>>;
|
|
542
|
+
readRestricted: z.ZodOptional<z.ZodBoolean>;
|
|
543
|
+
maxPages: z.ZodOptional<z.ZodNumber>;
|
|
544
|
+
}, z.core.$strict>, z.ZodTransform<{
|
|
545
|
+
id: string;
|
|
546
|
+
type: "confluence-export" | "sharepoint-export" | "confluence" | "ado-wiki" | "sharepoint" | "markdown-folder" | "git";
|
|
547
|
+
location: string;
|
|
548
|
+
spaces: string[];
|
|
549
|
+
owner?: string | undefined;
|
|
550
|
+
tags?: {
|
|
551
|
+
kinds: string[];
|
|
552
|
+
frameworks: string[];
|
|
553
|
+
} | undefined;
|
|
554
|
+
ref?: string | undefined;
|
|
555
|
+
path?: string | undefined;
|
|
556
|
+
checkout?: "clone" | "submodule" | undefined;
|
|
557
|
+
include?: string[] | undefined;
|
|
558
|
+
exclude?: string[] | undefined;
|
|
559
|
+
authority?: "platform" | "standard" | "framework" | "team" | "reference" | undefined;
|
|
560
|
+
byPage?: {
|
|
561
|
+
match: string[];
|
|
562
|
+
authority?: "platform" | "standard" | "framework" | "team" | "reference" | undefined;
|
|
563
|
+
status?: "current" | "deprecated" | "superseded" | "archived" | undefined;
|
|
564
|
+
}[] | undefined;
|
|
565
|
+
reviewMonths?: number | undefined;
|
|
566
|
+
appliesTo?: {
|
|
567
|
+
systems?: string[] | undefined;
|
|
568
|
+
components?: string[] | undefined;
|
|
569
|
+
platforms?: string[] | undefined;
|
|
570
|
+
repoTypes?: string[] | undefined;
|
|
571
|
+
frameworks?: string[] | undefined;
|
|
572
|
+
newComponents?: boolean | undefined;
|
|
573
|
+
} | undefined;
|
|
574
|
+
readRestricted?: boolean | undefined;
|
|
575
|
+
maxPages?: number | undefined;
|
|
576
|
+
}, {
|
|
577
|
+
id: string;
|
|
578
|
+
type: "confluence-export" | "sharepoint-export" | "confluence" | "ado-wiki" | "sharepoint" | "markdown-folder" | "git";
|
|
579
|
+
location: string;
|
|
580
|
+
spaces: string[];
|
|
581
|
+
owner?: string | undefined;
|
|
582
|
+
tags?: {
|
|
583
|
+
kinds: string[];
|
|
584
|
+
frameworks: string[];
|
|
585
|
+
} | undefined;
|
|
586
|
+
ref?: string | undefined;
|
|
587
|
+
path?: string | undefined;
|
|
588
|
+
checkout?: "clone" | "submodule" | undefined;
|
|
589
|
+
include?: string[] | undefined;
|
|
590
|
+
exclude?: string[] | undefined;
|
|
591
|
+
authority?: "platform" | "standard" | "framework" | "team" | "reference" | undefined;
|
|
592
|
+
byPage?: {
|
|
593
|
+
match: string[];
|
|
594
|
+
authority?: "platform" | "standard" | "framework" | "team" | "reference" | undefined;
|
|
595
|
+
status?: "current" | "deprecated" | "superseded" | "archived" | undefined;
|
|
596
|
+
}[] | undefined;
|
|
597
|
+
reviewMonths?: number | undefined;
|
|
598
|
+
appliesTo?: {
|
|
599
|
+
systems?: string[] | undefined;
|
|
600
|
+
components?: string[] | undefined;
|
|
601
|
+
platforms?: string[] | undefined;
|
|
602
|
+
repoTypes?: string[] | undefined;
|
|
603
|
+
frameworks?: string[] | undefined;
|
|
604
|
+
newComponents?: boolean | undefined;
|
|
605
|
+
} | undefined;
|
|
606
|
+
readRestricted?: boolean | undefined;
|
|
607
|
+
maxPages?: number | undefined;
|
|
608
|
+
}>>>>;
|
|
609
|
+
absorbed: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
610
|
+
id: z.ZodString;
|
|
611
|
+
url: z.ZodString;
|
|
612
|
+
format: z.ZodEnum<{
|
|
613
|
+
openspec: "openspec";
|
|
614
|
+
atticus: "atticus";
|
|
615
|
+
speckit: "speckit";
|
|
616
|
+
plain: "plain";
|
|
617
|
+
}>;
|
|
618
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
619
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
620
|
+
link: "link";
|
|
621
|
+
adopt: "adopt";
|
|
622
|
+
ignore: "ignore";
|
|
623
|
+
}>>;
|
|
624
|
+
}, z.core.$strict>>>;
|
|
625
|
+
}, z.core.$strict>;
|
|
626
|
+
/**
|
|
627
|
+
* Whether a page path inside a source matches a page pattern (sources.yaml `include` and
|
|
628
|
+
* `exclude`): `**` spans folders, `*` stays in one, `?` is one character, and a pattern ending
|
|
629
|
+
* in `/` or with no wildcard also takes everything under the folder it names.
|
|
630
|
+
*/
|
|
631
|
+
export declare function pageGlobMatches(glob: string, page: string): boolean;
|
|
632
|
+
/** Whether a source reads a page, by its `include` and `exclude` (sources.yaml version 2). */
|
|
633
|
+
export declare function sourceReadsPage(w: {
|
|
634
|
+
include?: string[] | undefined;
|
|
635
|
+
exclude?: string[] | undefined;
|
|
636
|
+
}, page: string): boolean;
|
|
637
|
+
/** The rank of an authority, 0 the most; a source without one ranks as a team's (ADR 0132). */
|
|
638
|
+
export declare function authorityRank(a: SourceAuthority | undefined): number;
|
|
639
|
+
/**
|
|
640
|
+
* The platforms each cloud runs (ADR 0132), so a source scoped to a cloud applies to a component
|
|
641
|
+
* that runs on one of its platforms, and one scoped to a platform to a component placed on its
|
|
642
|
+
* cloud. Lower case; an organisation names any other platform as it is.
|
|
643
|
+
*/
|
|
644
|
+
export declare const CLOUD_PLATFORMS: Record<string, readonly string[]>;
|
|
645
|
+
/**
|
|
646
|
+
* The first of a task's platforms a scope's platforms take in, a cloud standing for its platforms
|
|
647
|
+
* and a platform for its cloud; undefined when none is.
|
|
648
|
+
*/
|
|
649
|
+
export declare function platformsMatch(scope: readonly string[], places: readonly string[]): string | undefined;
|
|
650
|
+
/** What the page says of itself, for its standing: from front matter, an export's metadata, its text. */
|
|
651
|
+
export interface PageSignals {
|
|
652
|
+
labels?: readonly string[];
|
|
653
|
+
/** A status the page or its export states (Confluence status, a SharePoint column). */
|
|
654
|
+
status?: string;
|
|
655
|
+
/** The space or site is archived. */
|
|
656
|
+
spaceStatus?: string;
|
|
657
|
+
/** When it was last reviewed or updated, YYYY-MM-DD. */
|
|
658
|
+
updated?: string;
|
|
659
|
+
/** The page's text, for a banner near its top. */
|
|
660
|
+
text?: string;
|
|
661
|
+
}
|
|
662
|
+
/** A page's authority and status, and why, as its source, its overrides and the page itself say. */
|
|
663
|
+
export interface PageStanding {
|
|
664
|
+
authority: SourceAuthority;
|
|
665
|
+
status: PageStatus;
|
|
666
|
+
/** What set the authority or status when it isn't the source's own: "byPage Drafts/**", "label deprecated". */
|
|
667
|
+
by?: string;
|
|
668
|
+
/** A standard not reviewed within the source's reviewMonths: shown as "may be out of date". */
|
|
669
|
+
outOfDate?: {
|
|
670
|
+
since: string;
|
|
671
|
+
months: number;
|
|
672
|
+
};
|
|
673
|
+
}
|
|
674
|
+
/**
|
|
675
|
+
* A page's standing (ADR 0132), in three layers: the source's authority (default a team's); the
|
|
676
|
+
* first `byPage` pattern that matches the page; then what the page says of itself: a status or
|
|
677
|
+
* label (deprecated, superseded, archived), an archived space, or a banner at its top. A
|
|
678
|
+
* standard last updated more than the source's `reviewMonths` before `now` may be out of date.
|
|
679
|
+
*/
|
|
680
|
+
export declare function pageStanding(w: {
|
|
681
|
+
authority?: SourceAuthority | undefined;
|
|
682
|
+
byPage?: {
|
|
683
|
+
match: string[];
|
|
684
|
+
authority?: SourceAuthority | undefined;
|
|
685
|
+
status?: PageStatus | undefined;
|
|
686
|
+
}[] | undefined;
|
|
687
|
+
reviewMonths?: number | undefined;
|
|
688
|
+
}, page: string, signals: PageSignals, now?: string): PageStanding;
|
|
689
|
+
/** How a code repo runs a task (ADR 0030): Spec Kit inside the repo, or plain Atticus task files. */
|
|
690
|
+
export declare const BuildEngine: z.ZodEnum<{
|
|
691
|
+
atticus: "atticus";
|
|
692
|
+
speckit: "speckit";
|
|
693
|
+
}>;
|
|
694
|
+
export type BuildEngine = z.infer<typeof BuildEngine>;
|
|
695
|
+
export declare const Autonomy: z.ZodEnum<{
|
|
696
|
+
draft: "draft";
|
|
697
|
+
"plan-only": "plan-only";
|
|
698
|
+
"draft-and-pr": "draft-and-pr";
|
|
699
|
+
}>;
|
|
700
|
+
/**
|
|
701
|
+
* runtime.yaml's `retrieval` section (ADR 0116, defaults changed in its addendum):
|
|
702
|
+
* - embeddings.model: `bundled` (the default: the model installed with Atticus as the npm
|
|
703
|
+
* package @maycombhq/embed-model, all-MiniLM-L6-v2), `off`, or a folder with
|
|
704
|
+
* `atticus-model.yaml` (relative to the org pack); embeddings.runtime: a folder whose
|
|
705
|
+
* node_modules holds the onnxruntime packages, when they aren't beside Atticus. Where the model or onnxruntime isn't
|
|
706
|
+
* installed, the engine searches by words and names and says so. Nothing is ever downloaded.
|
|
707
|
+
* - expansion (on by default): one model call before a step's selection that names what the
|
|
708
|
+
* input is about and the names it uses (the step's gaps come from it).
|
|
709
|
+
* - rerank (off by default, not measured yet): one call that orders the candidates when they
|
|
710
|
+
* don't fit.
|
|
711
|
+
*/
|
|
712
|
+
export declare const RetrievalSettings: z.ZodObject<{
|
|
713
|
+
embeddings: z.ZodDefault<z.ZodObject<{
|
|
714
|
+
model: z.ZodDefault<z.ZodString>;
|
|
715
|
+
runtime: z.ZodOptional<z.ZodString>;
|
|
716
|
+
}, z.core.$strict>>;
|
|
717
|
+
expansion: z.ZodDefault<z.ZodBoolean>;
|
|
718
|
+
rerank: z.ZodDefault<z.ZodBoolean>;
|
|
719
|
+
}, z.core.$strict>;
|
|
720
|
+
export type RetrievalSettings = z.infer<typeof RetrievalSettings>;
|
|
721
|
+
/**
|
|
722
|
+
* The effective retrieval settings of a runtime.yaml (ADR 0116): its section with the defaults
|
|
723
|
+
* filled in, or the defaults when there is none. Every reader goes through this.
|
|
724
|
+
*/
|
|
725
|
+
export declare function retrievalOf(runtime?: {
|
|
726
|
+
retrieval?: z.input<typeof RetrievalSettings>;
|
|
727
|
+
} | null): RetrievalSettings;
|
|
728
|
+
/**
|
|
729
|
+
* The assistants Atticus writes slash commands, instructions and skills for (ADR 0121), each in
|
|
730
|
+
* the files that tool reads (@maycombhq/assistant-files). `agents-md` is any tool that reads
|
|
731
|
+
* AGENTS.md: Codex and others.
|
|
732
|
+
*/
|
|
733
|
+
export declare const ASSISTANTS: readonly ["copilot", "claude-code", "cursor", "gemini-cli", "windsurf", "agents-md"];
|
|
734
|
+
export declare const AssistantId: z.ZodEnum<{
|
|
735
|
+
copilot: "copilot";
|
|
736
|
+
"claude-code": "claude-code";
|
|
737
|
+
cursor: "cursor";
|
|
738
|
+
"gemini-cli": "gemini-cli";
|
|
739
|
+
windsurf: "windsurf";
|
|
740
|
+
"agents-md": "agents-md";
|
|
741
|
+
}>;
|
|
742
|
+
export type AssistantId = z.infer<typeof AssistantId>;
|
|
743
|
+
/**
|
|
744
|
+
* The kinds of AI step (C5, ADR 0121 addendum: per-step models). Each request's class is decided
|
|
745
|
+
* in code (`@maycombhq/ai` `stepClassOf`), never by its prompt, and picks the model it runs on:
|
|
746
|
+
* - read: reading repos into facts (atticus map and its fix round) and scan verify;
|
|
747
|
+
* - draft: the feature, architecture and stories drafts, small changes, change and spec drafts,
|
|
748
|
+
* scan surveys and their questions, dialect and framework drafts, tasks and tests;
|
|
749
|
+
* - critic: the critic's lenses and the hand-up lens;
|
|
750
|
+
* - knowledge: the knowledge scan and find, what a change needs (which items apply) and ask;
|
|
751
|
+
* - quick: everything else that's small: judgments, context expansion and ordering, names,
|
|
752
|
+
* glossary definitions, ticket text and explanations.
|
|
753
|
+
* Kept here, beside runtime.yaml's `models`, which names a model for each.
|
|
754
|
+
*/
|
|
755
|
+
export declare const STEP_CLASSES: readonly ["read", "draft", "critic", "knowledge", "quick"];
|
|
756
|
+
export declare const StepClass: z.ZodEnum<{
|
|
757
|
+
read: "read";
|
|
758
|
+
draft: "draft";
|
|
759
|
+
critic: "critic";
|
|
760
|
+
knowledge: "knowledge";
|
|
761
|
+
quick: "quick";
|
|
762
|
+
}>;
|
|
763
|
+
export type StepClass = z.infer<typeof StepClass>;
|
|
764
|
+
/**
|
|
765
|
+
* runtime.yaml's own schema version (ADR 0121 addendum). Version 2 adds a model per kind of step
|
|
766
|
+
* (`models.read`, `draft`, `critic`, `knowledge`, `quick`). A version 1 file still reads, every
|
|
767
|
+
* step on the one model; `atticus upgrade` moves it to version 2 (`runtime-v2`), changing nothing
|
|
768
|
+
* else.
|
|
769
|
+
*/
|
|
770
|
+
export declare const RUNTIME_SCHEMA_VERSION: 2;
|
|
771
|
+
export declare const Runtime: z.ZodObject<{
|
|
772
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
773
|
+
assistants: z.ZodObject<{
|
|
774
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
775
|
+
copilot: "copilot";
|
|
776
|
+
"claude-code": "claude-code";
|
|
777
|
+
cursor: "cursor";
|
|
778
|
+
"gemini-cli": "gemini-cli";
|
|
779
|
+
windsurf: "windsurf";
|
|
780
|
+
"agents-md": "agents-md";
|
|
781
|
+
}>>;
|
|
782
|
+
default: z.ZodEnum<{
|
|
783
|
+
copilot: "copilot";
|
|
784
|
+
"claude-code": "claude-code";
|
|
785
|
+
cursor: "cursor";
|
|
786
|
+
"gemini-cli": "gemini-cli";
|
|
787
|
+
windsurf: "windsurf";
|
|
788
|
+
"agents-md": "agents-md";
|
|
789
|
+
}>;
|
|
790
|
+
}, z.core.$strict>;
|
|
791
|
+
editors: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
792
|
+
vscode: "vscode";
|
|
793
|
+
intellij: "intellij";
|
|
794
|
+
}>>>;
|
|
795
|
+
ai: z.ZodDefault<z.ZodEnum<{
|
|
796
|
+
on: "on";
|
|
797
|
+
"text-only": "text-only";
|
|
798
|
+
off: "off";
|
|
799
|
+
}>>;
|
|
800
|
+
modes: z.ZodDefault<z.ZodObject<{
|
|
801
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
802
|
+
model: "model";
|
|
803
|
+
"hand-off": "hand-off";
|
|
804
|
+
"headless-claude-code": "headless-claude-code";
|
|
805
|
+
}>>;
|
|
806
|
+
default: z.ZodEnum<{
|
|
807
|
+
model: "model";
|
|
808
|
+
"hand-off": "hand-off";
|
|
809
|
+
"headless-claude-code": "headless-claude-code";
|
|
810
|
+
}>;
|
|
811
|
+
}, z.core.$strict>>;
|
|
812
|
+
models: z.ZodDefault<z.ZodObject<{
|
|
813
|
+
allowed: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
814
|
+
recommended: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
815
|
+
read: z.ZodOptional<z.ZodString>;
|
|
816
|
+
draft: z.ZodOptional<z.ZodString>;
|
|
817
|
+
critic: z.ZodOptional<z.ZodString>;
|
|
818
|
+
knowledge: z.ZodOptional<z.ZodString>;
|
|
819
|
+
quick: z.ZodOptional<z.ZodString>;
|
|
820
|
+
}, z.core.$strict>>;
|
|
821
|
+
autonomy: z.ZodDefault<z.ZodObject<{
|
|
822
|
+
default: z.ZodDefault<z.ZodEnum<{
|
|
823
|
+
draft: "draft";
|
|
824
|
+
"plan-only": "plan-only";
|
|
825
|
+
"draft-and-pr": "draft-and-pr";
|
|
826
|
+
}>>;
|
|
827
|
+
capPerRepo: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
|
|
828
|
+
draft: "draft";
|
|
829
|
+
"plan-only": "plan-only";
|
|
830
|
+
"draft-and-pr": "draft-and-pr";
|
|
831
|
+
}>>>;
|
|
832
|
+
maxFixRounds: z.ZodDefault<z.ZodNumber>;
|
|
833
|
+
}, z.core.$strict>>;
|
|
834
|
+
budgets: z.ZodDefault<z.ZodObject<{
|
|
835
|
+
defaultTokens: z.ZodDefault<z.ZodNumber>;
|
|
836
|
+
perAgent: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
|
|
837
|
+
}, z.core.$strict>>;
|
|
838
|
+
retention: z.ZodDefault<z.ZodObject<{
|
|
839
|
+
runsDays: z.ZodDefault<z.ZodNumber>;
|
|
840
|
+
}, z.core.$strict>>;
|
|
841
|
+
history: z.ZodOptional<z.ZodObject<{
|
|
842
|
+
record: z.ZodDefault<z.ZodBoolean>;
|
|
843
|
+
}, z.core.$strict>>;
|
|
844
|
+
retrieval: z.ZodOptional<z.ZodObject<{
|
|
845
|
+
embeddings: z.ZodDefault<z.ZodObject<{
|
|
846
|
+
model: z.ZodDefault<z.ZodString>;
|
|
847
|
+
runtime: z.ZodOptional<z.ZodString>;
|
|
848
|
+
}, z.core.$strict>>;
|
|
849
|
+
expansion: z.ZodDefault<z.ZodBoolean>;
|
|
850
|
+
rerank: z.ZodDefault<z.ZodBoolean>;
|
|
851
|
+
}, z.core.$strict>>;
|
|
852
|
+
telemetry: z.ZodDefault<z.ZodObject<{
|
|
853
|
+
enabled: z.ZodDefault<z.ZodBoolean>;
|
|
854
|
+
}, z.core.$strict>>;
|
|
855
|
+
adapters: z.ZodDefault<z.ZodObject<{
|
|
856
|
+
workTracker: z.ZodOptional<z.ZodObject<{
|
|
857
|
+
type: z.ZodEnum<{
|
|
858
|
+
[x: string]: string;
|
|
859
|
+
}>;
|
|
860
|
+
settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
861
|
+
}, z.core.$strict>>;
|
|
862
|
+
serviceDesk: z.ZodOptional<z.ZodObject<{
|
|
863
|
+
type: z.ZodEnum<{
|
|
864
|
+
[x: string]: string;
|
|
865
|
+
}>;
|
|
866
|
+
settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
867
|
+
}, z.core.$strict>>;
|
|
868
|
+
gitHost: z.ZodOptional<z.ZodObject<{
|
|
869
|
+
type: z.ZodEnum<{
|
|
870
|
+
[x: string]: string;
|
|
871
|
+
}>;
|
|
872
|
+
settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
873
|
+
}, z.core.$strict>>;
|
|
874
|
+
wiki: z.ZodOptional<z.ZodObject<{
|
|
875
|
+
type: z.ZodEnum<{
|
|
876
|
+
[x: string]: string;
|
|
877
|
+
}>;
|
|
878
|
+
settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
879
|
+
}, z.core.$strict>>;
|
|
880
|
+
notify: z.ZodOptional<z.ZodObject<{
|
|
881
|
+
type: z.ZodEnum<{
|
|
882
|
+
[x: string]: string;
|
|
883
|
+
}>;
|
|
884
|
+
settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
885
|
+
}, z.core.$strict>>;
|
|
886
|
+
design: z.ZodOptional<z.ZodObject<{
|
|
887
|
+
type: z.ZodEnum<{
|
|
888
|
+
[x: string]: string;
|
|
889
|
+
}>;
|
|
890
|
+
settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
891
|
+
}, z.core.$strict>>;
|
|
892
|
+
model: z.ZodOptional<z.ZodObject<{
|
|
893
|
+
type: z.ZodUnion<readonly [z.ZodEnum<{
|
|
894
|
+
mock: "mock";
|
|
895
|
+
anthropic: "anthropic";
|
|
896
|
+
"openai-compatible": "openai-compatible";
|
|
897
|
+
"azure-openai": "azure-openai";
|
|
898
|
+
bedrock: "bedrock";
|
|
899
|
+
vertex: "vertex";
|
|
900
|
+
}>, z.ZodString]>;
|
|
901
|
+
settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
902
|
+
}, z.core.$strict>>;
|
|
903
|
+
}, z.core.$strict>>;
|
|
904
|
+
buildEngine: z.ZodOptional<z.ZodObject<{
|
|
905
|
+
default: z.ZodDefault<z.ZodEnum<{
|
|
906
|
+
atticus: "atticus";
|
|
907
|
+
speckit: "speckit";
|
|
908
|
+
}>>;
|
|
909
|
+
perRepo: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
|
|
910
|
+
atticus: "atticus";
|
|
911
|
+
speckit: "speckit";
|
|
912
|
+
}>>>;
|
|
913
|
+
}, z.core.$strict>>;
|
|
914
|
+
}, z.core.$strict>;
|
|
915
|
+
export type Runtime = z.infer<typeof Runtime>;
|
|
916
|
+
/** runtime.yaml's model for each kind of step, those it names (ADR 0121 addendum). */
|
|
917
|
+
export declare function stepModelsOf(runtime: Pick<Runtime, "models"> | undefined): Partial<Record<StepClass, string>>;
|
|
918
|
+
/** Front matter of a skill (process/skills/<id>/SKILL.md). The body is the instructions. */
|
|
919
|
+
export declare const SkillMeta: z.ZodObject<{
|
|
920
|
+
id: z.ZodString;
|
|
921
|
+
name: z.ZodString;
|
|
922
|
+
description: z.ZodString;
|
|
923
|
+
appliesTo: z.ZodDefault<z.ZodObject<{
|
|
924
|
+
repoTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
925
|
+
artifacts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
926
|
+
interfaces: "interfaces";
|
|
927
|
+
data: "data";
|
|
928
|
+
ux: "ux";
|
|
929
|
+
brief: "brief";
|
|
930
|
+
proposal: "proposal";
|
|
931
|
+
specs: "specs";
|
|
932
|
+
mappings: "mappings";
|
|
933
|
+
design: "design";
|
|
934
|
+
stories: "stories";
|
|
935
|
+
tasks: "tasks";
|
|
936
|
+
snow: "snow";
|
|
937
|
+
}>>>;
|
|
938
|
+
changeTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
939
|
+
}, z.core.$strict>>;
|
|
940
|
+
owner: z.ZodString;
|
|
941
|
+
source: z.ZodString;
|
|
942
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
943
|
+
retired: "retired";
|
|
944
|
+
active: "active";
|
|
945
|
+
draft: "draft";
|
|
946
|
+
stale: "stale";
|
|
947
|
+
}>>;
|
|
948
|
+
reviewedAt: z.ZodOptional<z.ZodISODate>;
|
|
949
|
+
}, z.core.$strict>;
|
|
950
|
+
/** A service-desk request template (process/snow/<id>.yaml). */
|
|
951
|
+
export declare const ServiceRequestTemplate: z.ZodObject<{
|
|
952
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
953
|
+
id: z.ZodString;
|
|
954
|
+
name: z.ZodString;
|
|
955
|
+
requestType: z.ZodString;
|
|
956
|
+
fields: z.ZodArray<z.ZodObject<{
|
|
957
|
+
name: z.ZodString;
|
|
958
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
959
|
+
from: z.ZodOptional<z.ZodString>;
|
|
960
|
+
help: z.ZodOptional<z.ZodString>;
|
|
961
|
+
}, z.core.$strict>>;
|
|
962
|
+
approvers: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
963
|
+
leadTimeDays: z.ZodNumber;
|
|
964
|
+
triggers: z.ZodArray<z.ZodObject<{
|
|
965
|
+
kind: z.ZodEnum<{
|
|
966
|
+
System: "System";
|
|
967
|
+
Component: "Component";
|
|
968
|
+
Endpoint: "Endpoint";
|
|
969
|
+
Interface: "Interface";
|
|
970
|
+
GatewayRoute: "GatewayRoute";
|
|
971
|
+
Schema: "Schema";
|
|
972
|
+
FieldMapping: "FieldMapping";
|
|
973
|
+
DataStore: "DataStore";
|
|
974
|
+
Table: "Table";
|
|
975
|
+
Column: "Column";
|
|
976
|
+
IndexConstraint: "IndexConstraint";
|
|
977
|
+
Migration: "Migration";
|
|
978
|
+
Deployment: "Deployment";
|
|
979
|
+
Setting: "Setting";
|
|
980
|
+
ObservabilityAsset: "ObservabilityAsset";
|
|
981
|
+
AccessGrant: "AccessGrant";
|
|
982
|
+
QualityAsset: "QualityAsset";
|
|
983
|
+
Obligation: "Obligation";
|
|
984
|
+
GlossaryTerm: "GlossaryTerm";
|
|
985
|
+
Pattern: "Pattern";
|
|
986
|
+
Decision: "Decision";
|
|
987
|
+
SourceDocument: "SourceDocument";
|
|
988
|
+
Party: "Party";
|
|
989
|
+
Product: "Product";
|
|
990
|
+
Initiative: "Initiative";
|
|
991
|
+
Commitment: "Commitment";
|
|
992
|
+
OwnerQuestion: "OwnerQuestion";
|
|
993
|
+
ProcessDefinition: "ProcessDefinition";
|
|
994
|
+
ProcessArtifact: "ProcessArtifact";
|
|
995
|
+
Capability: "Capability";
|
|
996
|
+
Flow: "Flow";
|
|
997
|
+
Unresolved: "Unresolved";
|
|
998
|
+
CuratedDecision: "CuratedDecision";
|
|
999
|
+
}>;
|
|
1000
|
+
change: z.ZodEnum<{
|
|
1001
|
+
"planned-new": "planned-new";
|
|
1002
|
+
"planned-modify": "planned-modify";
|
|
1003
|
+
"planned-retire": "planned-retire";
|
|
1004
|
+
}>;
|
|
1005
|
+
where: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
1006
|
+
}, z.core.$strict>>;
|
|
1007
|
+
alsoNeeds: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1008
|
+
}, z.core.$strict>;
|
|
1009
|
+
/**
|
|
1010
|
+
* A procedure (ADR 0033): a named, ordered list of steps in an outside system, each with typed
|
|
1011
|
+
* inputs and outputs, whether it writes, and where the knowledge came from. Drafted from the
|
|
1012
|
+
* organisation's how-to pages, uploads and past tickets, reviewed by a person, kept here.
|
|
1013
|
+
* Additive C6 file kind: no schema version bump. `executors.allowed` is the allowlist: an
|
|
1014
|
+
* executor may run this procedure only if it is named here (off by default).
|
|
1015
|
+
*/
|
|
1016
|
+
export declare const Procedure: z.ZodObject<{
|
|
1017
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
1018
|
+
id: z.ZodString;
|
|
1019
|
+
name: z.ZodString;
|
|
1020
|
+
description: z.ZodOptional<z.ZodString>;
|
|
1021
|
+
system: z.ZodEnum<{
|
|
1022
|
+
other: "other";
|
|
1023
|
+
wiki: "wiki";
|
|
1024
|
+
design: "design";
|
|
1025
|
+
"work-tracker": "work-tracker";
|
|
1026
|
+
"service-desk": "service-desk";
|
|
1027
|
+
"git-host": "git-host";
|
|
1028
|
+
notify: "notify";
|
|
1029
|
+
}>;
|
|
1030
|
+
template: z.ZodOptional<z.ZodString>;
|
|
1031
|
+
steps: z.ZodArray<z.ZodObject<{
|
|
1032
|
+
id: z.ZodString;
|
|
1033
|
+
name: z.ZodString;
|
|
1034
|
+
kind: z.ZodString;
|
|
1035
|
+
writes: z.ZodBoolean;
|
|
1036
|
+
inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1037
|
+
outputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
1038
|
+
instructions: z.ZodOptional<z.ZodString>;
|
|
1039
|
+
evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1040
|
+
source: z.ZodString;
|
|
1041
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
1042
|
+
note: z.ZodOptional<z.ZodString>;
|
|
1043
|
+
}, z.core.$strict>>>;
|
|
1044
|
+
}, z.core.$strict>>;
|
|
1045
|
+
executors: z.ZodDefault<z.ZodObject<{
|
|
1046
|
+
allowed: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1047
|
+
remoteHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1048
|
+
}, z.core.$strict>>;
|
|
1049
|
+
source: z.ZodString;
|
|
1050
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
1051
|
+
retired: "retired";
|
|
1052
|
+
active: "active";
|
|
1053
|
+
draft: "draft";
|
|
1054
|
+
}>>;
|
|
1055
|
+
reviewedBy: z.ZodOptional<z.ZodString>;
|
|
1056
|
+
reviewedAt: z.ZodOptional<z.ZodISODate>;
|
|
1057
|
+
}, z.core.$strict>;
|
|
1058
|
+
export type Procedure = z.infer<typeof Procedure>;
|
|
1059
|
+
export declare const TestType: z.ZodEnum<{
|
|
1060
|
+
unit: "unit";
|
|
1061
|
+
contract: "contract";
|
|
1062
|
+
integration: "integration";
|
|
1063
|
+
e2e: "e2e";
|
|
1064
|
+
regression: "regression";
|
|
1065
|
+
performance: "performance";
|
|
1066
|
+
security: "security";
|
|
1067
|
+
accessibility: "accessibility";
|
|
1068
|
+
"data-migration": "data-migration";
|
|
1069
|
+
}>;
|
|
1070
|
+
export declare const TestStrategy: z.ZodObject<{
|
|
1071
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
1072
|
+
matrix: z.ZodArray<z.ZodObject<{
|
|
1073
|
+
changeType: z.ZodString;
|
|
1074
|
+
risk: z.ZodEnum<{
|
|
1075
|
+
low: "low";
|
|
1076
|
+
medium: "medium";
|
|
1077
|
+
high: "high";
|
|
1078
|
+
}>;
|
|
1079
|
+
required: z.ZodArray<z.ZodEnum<{
|
|
1080
|
+
unit: "unit";
|
|
1081
|
+
contract: "contract";
|
|
1082
|
+
integration: "integration";
|
|
1083
|
+
e2e: "e2e";
|
|
1084
|
+
regression: "regression";
|
|
1085
|
+
performance: "performance";
|
|
1086
|
+
security: "security";
|
|
1087
|
+
accessibility: "accessibility";
|
|
1088
|
+
"data-migration": "data-migration";
|
|
1089
|
+
}>>;
|
|
1090
|
+
}, z.core.$strict>>;
|
|
1091
|
+
definitionOfReady: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1092
|
+
}, z.core.$strict>;
|
|
1093
|
+
/** A range of ideal developer days: 20%, 50% and 80% of like work took at most this long. */
|
|
1094
|
+
export declare const DayRange: z.ZodObject<{
|
|
1095
|
+
p20: z.ZodNumber;
|
|
1096
|
+
p50: z.ZodNumber;
|
|
1097
|
+
p80: z.ZodNumber;
|
|
1098
|
+
}, z.core.$strict>;
|
|
1099
|
+
/**
|
|
1100
|
+
* The reference ranges an estimate starts from, before past changes calibrate it: per class of
|
|
1101
|
+
* work (a target flow's step, `<op>/<kind>` and what it reaches, e.g. add/call-out/vendor/new-entry),
|
|
1102
|
+
* the days like work takes. Who agreed the figures is required: a range nobody stands behind is
|
|
1103
|
+
* not an estimate.
|
|
1104
|
+
*/
|
|
1105
|
+
export declare const Estimates: z.ZodObject<{
|
|
1106
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
1107
|
+
source: z.ZodString;
|
|
1108
|
+
classes: z.ZodArray<z.ZodObject<{
|
|
1109
|
+
match: z.ZodString;
|
|
1110
|
+
days: z.ZodObject<{
|
|
1111
|
+
p20: z.ZodNumber;
|
|
1112
|
+
p50: z.ZodNumber;
|
|
1113
|
+
p80: z.ZodNumber;
|
|
1114
|
+
}, z.core.$strict>;
|
|
1115
|
+
why: z.ZodOptional<z.ZodString>;
|
|
1116
|
+
}, z.core.$strict>>;
|
|
1117
|
+
perExtraRepo: z.ZodOptional<z.ZodObject<{
|
|
1118
|
+
p20: z.ZodNumber;
|
|
1119
|
+
p50: z.ZodNumber;
|
|
1120
|
+
p80: z.ZodNumber;
|
|
1121
|
+
}, z.core.$strict>>;
|
|
1122
|
+
risks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
|
|
1123
|
+
}, z.core.$strict>;
|
|
1124
|
+
export type Estimates = z.infer<typeof Estimates>;
|
|
1125
|
+
/**
|
|
1126
|
+
* What Atticus does with OpenSpec's stores (beta; ADR 0126, an addendum to ADR 0006). A new,
|
|
1127
|
+
* optional file: a pack without it reads no store and hand-down adds no reference, as before.
|
|
1128
|
+
* Atticus never registers, clones, pulls, pushes or writes into a store.
|
|
1129
|
+
*/
|
|
1130
|
+
export declare const OpenSpecSettings: z.ZodObject<{
|
|
1131
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
1132
|
+
stores: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1133
|
+
path: z.ZodString;
|
|
1134
|
+
label: z.ZodOptional<z.ZodString>;
|
|
1135
|
+
}, z.core.$strict>>>;
|
|
1136
|
+
referenceInRepos: z.ZodDefault<z.ZodBoolean>;
|
|
1137
|
+
}, z.core.$strict>;
|
|
1138
|
+
export type OpenSpecSettings = z.infer<typeof OpenSpecSettings>;
|
|
1139
|
+
/** One gateway route a person says an unscanned system calls (ADR 0124 addendum A-callers). */
|
|
1140
|
+
export declare const DeclaredCall: z.ZodObject<{
|
|
1141
|
+
as: z.ZodOptional<z.ZodEnum<{
|
|
1142
|
+
product: "product";
|
|
1143
|
+
subject: "subject";
|
|
1144
|
+
app: "app";
|
|
1145
|
+
"client-id": "client-id";
|
|
1146
|
+
}>>;
|
|
1147
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1148
|
+
route: z.ZodOptional<z.ZodString>;
|
|
1149
|
+
}, z.core.$strict>;
|
|
1150
|
+
export type DeclaredCall = z.infer<typeof DeclaredCall>;
|
|
1151
|
+
export declare const Profile: z.ZodObject<{
|
|
1152
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
1153
|
+
platform: z.ZodString;
|
|
1154
|
+
name: z.ZodString;
|
|
1155
|
+
systems: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1156
|
+
id: z.ZodString;
|
|
1157
|
+
name: z.ZodString;
|
|
1158
|
+
boundary: z.ZodEnum<{
|
|
1159
|
+
product: "product";
|
|
1160
|
+
internal: "internal";
|
|
1161
|
+
vendor: "vendor";
|
|
1162
|
+
}>;
|
|
1163
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
1164
|
+
aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1165
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1166
|
+
calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1167
|
+
as: z.ZodOptional<z.ZodEnum<{
|
|
1168
|
+
product: "product";
|
|
1169
|
+
subject: "subject";
|
|
1170
|
+
app: "app";
|
|
1171
|
+
"client-id": "client-id";
|
|
1172
|
+
}>>;
|
|
1173
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1174
|
+
route: z.ZodOptional<z.ZodString>;
|
|
1175
|
+
}, z.core.$strict>>>;
|
|
1176
|
+
}, z.core.$strict>>>;
|
|
1177
|
+
environments: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1178
|
+
legend: z.ZodDefault<z.ZodObject<{
|
|
1179
|
+
new: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1180
|
+
modify: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1181
|
+
retire: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1182
|
+
}, z.core.$strict>>;
|
|
1183
|
+
gates: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1184
|
+
}, z.core.$strict>;
|
|
1185
|
+
export type Profile = z.infer<typeof Profile>;
|