@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,558 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
/**
|
|
3
|
+
* Contract C3: checklist rules (`org-pack/checklists/*.yaml`) and critic findings
|
|
4
|
+
* (`openspec/changes/<id>/review/<gate>/<round>/<finding-id>.yaml`). See ADR 0011.
|
|
5
|
+
*/
|
|
6
|
+
export declare const REVIEW_SCHEMA_VERSION: 1;
|
|
7
|
+
/**
|
|
8
|
+
* The four questions the critic asks of every draft (ADR 0124 addendum, Part 4): is it true to
|
|
9
|
+
* the code, is it complete, is it safe to build, can it ship. Each is answered by code first (the
|
|
10
|
+
* deterministic checks) and then by one AI lens in a fresh session. On screen the critic is
|
|
11
|
+
* always called "Critic".
|
|
12
|
+
*/
|
|
13
|
+
export declare const CriticQuestion: z.ZodEnum<{
|
|
14
|
+
true: "true";
|
|
15
|
+
complete: "complete";
|
|
16
|
+
safe: "safe";
|
|
17
|
+
ship: "ship";
|
|
18
|
+
}>;
|
|
19
|
+
export type CriticQuestion = z.infer<typeof CriticQuestion>;
|
|
20
|
+
/**
|
|
21
|
+
* The seven role lenses the critic ran before the four questions (ADR 0034). Still read, so an
|
|
22
|
+
* org pack written for them keeps working: each maps to the question that took it over.
|
|
23
|
+
*/
|
|
24
|
+
export declare const LEGACY_LENSES: readonly ["business", "architecture", "story", "ux", "delivery", "code-and-test", "release"];
|
|
25
|
+
export type LegacyLens = (typeof LEGACY_LENSES)[number];
|
|
26
|
+
/**
|
|
27
|
+
* A rule's lens: one of the four questions, or one of the seven old role lenses (read as the
|
|
28
|
+
* question it maps to). C3, widened additively; no schema version bump.
|
|
29
|
+
*/
|
|
30
|
+
export declare const Lens: z.ZodEnum<{
|
|
31
|
+
true: "true";
|
|
32
|
+
complete: "complete";
|
|
33
|
+
safe: "safe";
|
|
34
|
+
ship: "ship";
|
|
35
|
+
business: "business";
|
|
36
|
+
architecture: "architecture";
|
|
37
|
+
story: "story";
|
|
38
|
+
ux: "ux";
|
|
39
|
+
delivery: "delivery";
|
|
40
|
+
"code-and-test": "code-and-test";
|
|
41
|
+
release: "release";
|
|
42
|
+
}>;
|
|
43
|
+
export type Lens = z.infer<typeof Lens>;
|
|
44
|
+
export declare const isCriticQuestion: (l: string) => l is CriticQuestion;
|
|
45
|
+
/** The question a lens asks: itself for a question, the question that took over an old lens. */
|
|
46
|
+
export declare function questionOfLens(l: Lens): CriticQuestion;
|
|
47
|
+
/**
|
|
48
|
+
* The questions a lens covers when a change type lists it: a question covers itself; an old
|
|
49
|
+
* lens covers what it used to review (the architecture lens also reviewed what is now safe).
|
|
50
|
+
*/
|
|
51
|
+
export declare function lensCovers(l: Lens): CriticQuestion[];
|
|
52
|
+
/** Where a rule comes from. Constitution rules can never be waived. */
|
|
53
|
+
export declare const Layer: z.ZodEnum<{
|
|
54
|
+
team: "team";
|
|
55
|
+
constitution: "constitution";
|
|
56
|
+
org: "org";
|
|
57
|
+
}>;
|
|
58
|
+
/** gap is reserved for knowledge-gap findings. */
|
|
59
|
+
export declare const Severity: z.ZodEnum<{
|
|
60
|
+
blocking: "blocking";
|
|
61
|
+
gap: "gap";
|
|
62
|
+
risk: "risk";
|
|
63
|
+
idea: "idea";
|
|
64
|
+
}>;
|
|
65
|
+
export declare const RuleSeverity: z.ZodEnum<{
|
|
66
|
+
blocking: "blocking";
|
|
67
|
+
risk: "risk";
|
|
68
|
+
idea: "idea";
|
|
69
|
+
}>;
|
|
70
|
+
/** Change artifacts a rule can look at (org-flow schema), plus the catalog and code. */
|
|
71
|
+
export declare const ReviewArtifact: z.ZodEnum<{
|
|
72
|
+
code: "code";
|
|
73
|
+
interfaces: "interfaces";
|
|
74
|
+
data: "data";
|
|
75
|
+
ux: "ux";
|
|
76
|
+
release: "release";
|
|
77
|
+
brief: "brief";
|
|
78
|
+
proposal: "proposal";
|
|
79
|
+
specs: "specs";
|
|
80
|
+
mappings: "mappings";
|
|
81
|
+
design: "design";
|
|
82
|
+
stories: "stories";
|
|
83
|
+
tasks: "tasks";
|
|
84
|
+
snow: "snow";
|
|
85
|
+
tests: "tests";
|
|
86
|
+
catalog: "catalog";
|
|
87
|
+
}>;
|
|
88
|
+
/**
|
|
89
|
+
* A fact a rule depends on. When it is missing or older than `freshForDays` for a system
|
|
90
|
+
* the change touches, the critic raises a knowledge-gap finding instead of passing.
|
|
91
|
+
*/
|
|
92
|
+
export declare const RuleNeed: z.ZodObject<{
|
|
93
|
+
kind: z.ZodEnum<{
|
|
94
|
+
System: "System";
|
|
95
|
+
Component: "Component";
|
|
96
|
+
Endpoint: "Endpoint";
|
|
97
|
+
Interface: "Interface";
|
|
98
|
+
GatewayRoute: "GatewayRoute";
|
|
99
|
+
Schema: "Schema";
|
|
100
|
+
FieldMapping: "FieldMapping";
|
|
101
|
+
DataStore: "DataStore";
|
|
102
|
+
Table: "Table";
|
|
103
|
+
Column: "Column";
|
|
104
|
+
IndexConstraint: "IndexConstraint";
|
|
105
|
+
Migration: "Migration";
|
|
106
|
+
Deployment: "Deployment";
|
|
107
|
+
Setting: "Setting";
|
|
108
|
+
ObservabilityAsset: "ObservabilityAsset";
|
|
109
|
+
AccessGrant: "AccessGrant";
|
|
110
|
+
QualityAsset: "QualityAsset";
|
|
111
|
+
Obligation: "Obligation";
|
|
112
|
+
GlossaryTerm: "GlossaryTerm";
|
|
113
|
+
Pattern: "Pattern";
|
|
114
|
+
Decision: "Decision";
|
|
115
|
+
SourceDocument: "SourceDocument";
|
|
116
|
+
Party: "Party";
|
|
117
|
+
Product: "Product";
|
|
118
|
+
Initiative: "Initiative";
|
|
119
|
+
Commitment: "Commitment";
|
|
120
|
+
OwnerQuestion: "OwnerQuestion";
|
|
121
|
+
ProcessDefinition: "ProcessDefinition";
|
|
122
|
+
ProcessArtifact: "ProcessArtifact";
|
|
123
|
+
Capability: "Capability";
|
|
124
|
+
Flow: "Flow";
|
|
125
|
+
Unresolved: "Unresolved";
|
|
126
|
+
CuratedDecision: "CuratedDecision";
|
|
127
|
+
}>;
|
|
128
|
+
field: z.ZodOptional<z.ZodString>;
|
|
129
|
+
scope: z.ZodDefault<z.ZodEnum<{
|
|
130
|
+
"touched-systems": "touched-systems";
|
|
131
|
+
"touched-components": "touched-components";
|
|
132
|
+
"touched-interfaces": "touched-interfaces";
|
|
133
|
+
"touched-data-stores": "touched-data-stores";
|
|
134
|
+
}>>;
|
|
135
|
+
freshForDays: z.ZodOptional<z.ZodNumber>;
|
|
136
|
+
question: z.ZodString;
|
|
137
|
+
}, z.core.$strict>;
|
|
138
|
+
export declare const DeterministicCheck: z.ZodObject<{
|
|
139
|
+
type: z.ZodLiteral<"deterministic">;
|
|
140
|
+
check: z.ZodString;
|
|
141
|
+
params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
142
|
+
}, z.core.$strict>;
|
|
143
|
+
export declare const AiCheck: z.ZodObject<{
|
|
144
|
+
type: z.ZodLiteral<"ai">;
|
|
145
|
+
prompt: z.ZodString;
|
|
146
|
+
}, z.core.$strict>;
|
|
147
|
+
export declare const ChecklistRule: z.ZodObject<{
|
|
148
|
+
id: z.ZodString;
|
|
149
|
+
title: z.ZodString;
|
|
150
|
+
description: z.ZodOptional<z.ZodString>;
|
|
151
|
+
layer: z.ZodEnum<{
|
|
152
|
+
team: "team";
|
|
153
|
+
constitution: "constitution";
|
|
154
|
+
org: "org";
|
|
155
|
+
}>;
|
|
156
|
+
lens: z.ZodEnum<{
|
|
157
|
+
true: "true";
|
|
158
|
+
complete: "complete";
|
|
159
|
+
safe: "safe";
|
|
160
|
+
ship: "ship";
|
|
161
|
+
business: "business";
|
|
162
|
+
architecture: "architecture";
|
|
163
|
+
story: "story";
|
|
164
|
+
ux: "ux";
|
|
165
|
+
delivery: "delivery";
|
|
166
|
+
"code-and-test": "code-and-test";
|
|
167
|
+
release: "release";
|
|
168
|
+
}>;
|
|
169
|
+
question: z.ZodOptional<z.ZodEnum<{
|
|
170
|
+
true: "true";
|
|
171
|
+
complete: "complete";
|
|
172
|
+
safe: "safe";
|
|
173
|
+
ship: "ship";
|
|
174
|
+
}>>;
|
|
175
|
+
appliesTo: z.ZodObject<{
|
|
176
|
+
artifacts: z.ZodArray<z.ZodEnum<{
|
|
177
|
+
code: "code";
|
|
178
|
+
interfaces: "interfaces";
|
|
179
|
+
data: "data";
|
|
180
|
+
ux: "ux";
|
|
181
|
+
release: "release";
|
|
182
|
+
brief: "brief";
|
|
183
|
+
proposal: "proposal";
|
|
184
|
+
specs: "specs";
|
|
185
|
+
mappings: "mappings";
|
|
186
|
+
design: "design";
|
|
187
|
+
stories: "stories";
|
|
188
|
+
tasks: "tasks";
|
|
189
|
+
snow: "snow";
|
|
190
|
+
tests: "tests";
|
|
191
|
+
catalog: "catalog";
|
|
192
|
+
}>>;
|
|
193
|
+
changeTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
194
|
+
}, z.core.$strict>;
|
|
195
|
+
severity: z.ZodEnum<{
|
|
196
|
+
blocking: "blocking";
|
|
197
|
+
risk: "risk";
|
|
198
|
+
idea: "idea";
|
|
199
|
+
}>;
|
|
200
|
+
check: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
201
|
+
type: z.ZodLiteral<"deterministic">;
|
|
202
|
+
check: z.ZodString;
|
|
203
|
+
params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
204
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
205
|
+
type: z.ZodLiteral<"ai">;
|
|
206
|
+
prompt: z.ZodString;
|
|
207
|
+
}, z.core.$strict>], "type">;
|
|
208
|
+
evidenceRequired: z.ZodDefault<z.ZodBoolean>;
|
|
209
|
+
extends: z.ZodOptional<z.ZodString>;
|
|
210
|
+
tightens: z.ZodOptional<z.ZodString>;
|
|
211
|
+
waivable: z.ZodBoolean;
|
|
212
|
+
source: z.ZodString;
|
|
213
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
214
|
+
retired: "retired";
|
|
215
|
+
active: "active";
|
|
216
|
+
draft: "draft";
|
|
217
|
+
}>>;
|
|
218
|
+
needs: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
219
|
+
kind: z.ZodEnum<{
|
|
220
|
+
System: "System";
|
|
221
|
+
Component: "Component";
|
|
222
|
+
Endpoint: "Endpoint";
|
|
223
|
+
Interface: "Interface";
|
|
224
|
+
GatewayRoute: "GatewayRoute";
|
|
225
|
+
Schema: "Schema";
|
|
226
|
+
FieldMapping: "FieldMapping";
|
|
227
|
+
DataStore: "DataStore";
|
|
228
|
+
Table: "Table";
|
|
229
|
+
Column: "Column";
|
|
230
|
+
IndexConstraint: "IndexConstraint";
|
|
231
|
+
Migration: "Migration";
|
|
232
|
+
Deployment: "Deployment";
|
|
233
|
+
Setting: "Setting";
|
|
234
|
+
ObservabilityAsset: "ObservabilityAsset";
|
|
235
|
+
AccessGrant: "AccessGrant";
|
|
236
|
+
QualityAsset: "QualityAsset";
|
|
237
|
+
Obligation: "Obligation";
|
|
238
|
+
GlossaryTerm: "GlossaryTerm";
|
|
239
|
+
Pattern: "Pattern";
|
|
240
|
+
Decision: "Decision";
|
|
241
|
+
SourceDocument: "SourceDocument";
|
|
242
|
+
Party: "Party";
|
|
243
|
+
Product: "Product";
|
|
244
|
+
Initiative: "Initiative";
|
|
245
|
+
Commitment: "Commitment";
|
|
246
|
+
OwnerQuestion: "OwnerQuestion";
|
|
247
|
+
ProcessDefinition: "ProcessDefinition";
|
|
248
|
+
ProcessArtifact: "ProcessArtifact";
|
|
249
|
+
Capability: "Capability";
|
|
250
|
+
Flow: "Flow";
|
|
251
|
+
Unresolved: "Unresolved";
|
|
252
|
+
CuratedDecision: "CuratedDecision";
|
|
253
|
+
}>;
|
|
254
|
+
field: z.ZodOptional<z.ZodString>;
|
|
255
|
+
scope: z.ZodDefault<z.ZodEnum<{
|
|
256
|
+
"touched-systems": "touched-systems";
|
|
257
|
+
"touched-components": "touched-components";
|
|
258
|
+
"touched-interfaces": "touched-interfaces";
|
|
259
|
+
"touched-data-stores": "touched-data-stores";
|
|
260
|
+
}>>;
|
|
261
|
+
freshForDays: z.ZodOptional<z.ZodNumber>;
|
|
262
|
+
question: z.ZodString;
|
|
263
|
+
}, z.core.$strict>>>;
|
|
264
|
+
}, z.core.$strict>;
|
|
265
|
+
export type ChecklistRule = z.infer<typeof ChecklistRule>;
|
|
266
|
+
/** A checklist file: one pack of rules. */
|
|
267
|
+
export declare const ChecklistPack: z.ZodObject<{
|
|
268
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
269
|
+
name: z.ZodString;
|
|
270
|
+
version: z.ZodString;
|
|
271
|
+
description: z.ZodOptional<z.ZodString>;
|
|
272
|
+
rules: z.ZodArray<z.ZodObject<{
|
|
273
|
+
id: z.ZodString;
|
|
274
|
+
title: z.ZodString;
|
|
275
|
+
description: z.ZodOptional<z.ZodString>;
|
|
276
|
+
layer: z.ZodEnum<{
|
|
277
|
+
team: "team";
|
|
278
|
+
constitution: "constitution";
|
|
279
|
+
org: "org";
|
|
280
|
+
}>;
|
|
281
|
+
lens: z.ZodEnum<{
|
|
282
|
+
true: "true";
|
|
283
|
+
complete: "complete";
|
|
284
|
+
safe: "safe";
|
|
285
|
+
ship: "ship";
|
|
286
|
+
business: "business";
|
|
287
|
+
architecture: "architecture";
|
|
288
|
+
story: "story";
|
|
289
|
+
ux: "ux";
|
|
290
|
+
delivery: "delivery";
|
|
291
|
+
"code-and-test": "code-and-test";
|
|
292
|
+
release: "release";
|
|
293
|
+
}>;
|
|
294
|
+
question: z.ZodOptional<z.ZodEnum<{
|
|
295
|
+
true: "true";
|
|
296
|
+
complete: "complete";
|
|
297
|
+
safe: "safe";
|
|
298
|
+
ship: "ship";
|
|
299
|
+
}>>;
|
|
300
|
+
appliesTo: z.ZodObject<{
|
|
301
|
+
artifacts: z.ZodArray<z.ZodEnum<{
|
|
302
|
+
code: "code";
|
|
303
|
+
interfaces: "interfaces";
|
|
304
|
+
data: "data";
|
|
305
|
+
ux: "ux";
|
|
306
|
+
release: "release";
|
|
307
|
+
brief: "brief";
|
|
308
|
+
proposal: "proposal";
|
|
309
|
+
specs: "specs";
|
|
310
|
+
mappings: "mappings";
|
|
311
|
+
design: "design";
|
|
312
|
+
stories: "stories";
|
|
313
|
+
tasks: "tasks";
|
|
314
|
+
snow: "snow";
|
|
315
|
+
tests: "tests";
|
|
316
|
+
catalog: "catalog";
|
|
317
|
+
}>>;
|
|
318
|
+
changeTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
319
|
+
}, z.core.$strict>;
|
|
320
|
+
severity: z.ZodEnum<{
|
|
321
|
+
blocking: "blocking";
|
|
322
|
+
risk: "risk";
|
|
323
|
+
idea: "idea";
|
|
324
|
+
}>;
|
|
325
|
+
check: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
326
|
+
type: z.ZodLiteral<"deterministic">;
|
|
327
|
+
check: z.ZodString;
|
|
328
|
+
params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
329
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
330
|
+
type: z.ZodLiteral<"ai">;
|
|
331
|
+
prompt: z.ZodString;
|
|
332
|
+
}, z.core.$strict>], "type">;
|
|
333
|
+
evidenceRequired: z.ZodDefault<z.ZodBoolean>;
|
|
334
|
+
extends: z.ZodOptional<z.ZodString>;
|
|
335
|
+
tightens: z.ZodOptional<z.ZodString>;
|
|
336
|
+
waivable: z.ZodBoolean;
|
|
337
|
+
source: z.ZodString;
|
|
338
|
+
status: z.ZodDefault<z.ZodEnum<{
|
|
339
|
+
retired: "retired";
|
|
340
|
+
active: "active";
|
|
341
|
+
draft: "draft";
|
|
342
|
+
}>>;
|
|
343
|
+
needs: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
344
|
+
kind: z.ZodEnum<{
|
|
345
|
+
System: "System";
|
|
346
|
+
Component: "Component";
|
|
347
|
+
Endpoint: "Endpoint";
|
|
348
|
+
Interface: "Interface";
|
|
349
|
+
GatewayRoute: "GatewayRoute";
|
|
350
|
+
Schema: "Schema";
|
|
351
|
+
FieldMapping: "FieldMapping";
|
|
352
|
+
DataStore: "DataStore";
|
|
353
|
+
Table: "Table";
|
|
354
|
+
Column: "Column";
|
|
355
|
+
IndexConstraint: "IndexConstraint";
|
|
356
|
+
Migration: "Migration";
|
|
357
|
+
Deployment: "Deployment";
|
|
358
|
+
Setting: "Setting";
|
|
359
|
+
ObservabilityAsset: "ObservabilityAsset";
|
|
360
|
+
AccessGrant: "AccessGrant";
|
|
361
|
+
QualityAsset: "QualityAsset";
|
|
362
|
+
Obligation: "Obligation";
|
|
363
|
+
GlossaryTerm: "GlossaryTerm";
|
|
364
|
+
Pattern: "Pattern";
|
|
365
|
+
Decision: "Decision";
|
|
366
|
+
SourceDocument: "SourceDocument";
|
|
367
|
+
Party: "Party";
|
|
368
|
+
Product: "Product";
|
|
369
|
+
Initiative: "Initiative";
|
|
370
|
+
Commitment: "Commitment";
|
|
371
|
+
OwnerQuestion: "OwnerQuestion";
|
|
372
|
+
ProcessDefinition: "ProcessDefinition";
|
|
373
|
+
ProcessArtifact: "ProcessArtifact";
|
|
374
|
+
Capability: "Capability";
|
|
375
|
+
Flow: "Flow";
|
|
376
|
+
Unresolved: "Unresolved";
|
|
377
|
+
CuratedDecision: "CuratedDecision";
|
|
378
|
+
}>;
|
|
379
|
+
field: z.ZodOptional<z.ZodString>;
|
|
380
|
+
scope: z.ZodDefault<z.ZodEnum<{
|
|
381
|
+
"touched-systems": "touched-systems";
|
|
382
|
+
"touched-components": "touched-components";
|
|
383
|
+
"touched-interfaces": "touched-interfaces";
|
|
384
|
+
"touched-data-stores": "touched-data-stores";
|
|
385
|
+
}>>;
|
|
386
|
+
freshForDays: z.ZodOptional<z.ZodNumber>;
|
|
387
|
+
question: z.ZodString;
|
|
388
|
+
}, z.core.$strict>>>;
|
|
389
|
+
}, z.core.$strict>>;
|
|
390
|
+
}, z.core.$strict>;
|
|
391
|
+
export type ChecklistPack = z.infer<typeof ChecklistPack>;
|
|
392
|
+
export declare const FindingEvidence: z.ZodObject<{
|
|
393
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
394
|
+
code: "code";
|
|
395
|
+
config: "config";
|
|
396
|
+
spec: "spec";
|
|
397
|
+
gateway: "gateway";
|
|
398
|
+
"event-config": "event-config";
|
|
399
|
+
infrastructure: "infrastructure";
|
|
400
|
+
pipeline: "pipeline";
|
|
401
|
+
migration: "migration";
|
|
402
|
+
diagram: "diagram";
|
|
403
|
+
document: "document";
|
|
404
|
+
export: "export";
|
|
405
|
+
manual: "manual";
|
|
406
|
+
}>, z.ZodEnum<{
|
|
407
|
+
catalog: "catalog";
|
|
408
|
+
artifact: "artifact";
|
|
409
|
+
rule: "rule";
|
|
410
|
+
}>]>;
|
|
411
|
+
record: z.ZodOptional<z.ZodString>;
|
|
412
|
+
path: z.ZodOptional<z.ZodString>;
|
|
413
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
414
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
415
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
416
|
+
}, z.core.$strict>;
|
|
417
|
+
export declare const FindingLocator: z.ZodObject<{
|
|
418
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
419
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
420
|
+
record: z.ZodOptional<z.ZodString>;
|
|
421
|
+
field: z.ZodOptional<z.ZodString>;
|
|
422
|
+
}, z.core.$strict>;
|
|
423
|
+
export declare const FindingState: z.ZodEnum<{
|
|
424
|
+
open: "open";
|
|
425
|
+
applied: "applied";
|
|
426
|
+
dismissed: "dismissed";
|
|
427
|
+
waived: "waived";
|
|
428
|
+
asked: "asked";
|
|
429
|
+
}>;
|
|
430
|
+
export declare const FindingAction: z.ZodEnum<{
|
|
431
|
+
apply: "apply";
|
|
432
|
+
"edit-and-apply": "edit-and-apply";
|
|
433
|
+
"not-relevant": "not-relevant";
|
|
434
|
+
waive: "waive";
|
|
435
|
+
ask: "ask";
|
|
436
|
+
}>;
|
|
437
|
+
export declare const FindingResolution: z.ZodObject<{
|
|
438
|
+
action: z.ZodEnum<{
|
|
439
|
+
apply: "apply";
|
|
440
|
+
"edit-and-apply": "edit-and-apply";
|
|
441
|
+
"not-relevant": "not-relevant";
|
|
442
|
+
waive: "waive";
|
|
443
|
+
ask: "ask";
|
|
444
|
+
}>;
|
|
445
|
+
by: z.ZodString;
|
|
446
|
+
at: z.ZodISODateTime;
|
|
447
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
448
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
449
|
+
}, z.core.$strict>;
|
|
450
|
+
export declare const Finding: z.ZodObject<{
|
|
451
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
452
|
+
id: z.ZodString;
|
|
453
|
+
kind: z.ZodEnum<{
|
|
454
|
+
issue: "issue";
|
|
455
|
+
"knowledge-gap": "knowledge-gap";
|
|
456
|
+
}>;
|
|
457
|
+
change: z.ZodString;
|
|
458
|
+
gate: z.ZodString;
|
|
459
|
+
round: z.ZodNumber;
|
|
460
|
+
rule: z.ZodString;
|
|
461
|
+
layer: z.ZodEnum<{
|
|
462
|
+
team: "team";
|
|
463
|
+
constitution: "constitution";
|
|
464
|
+
org: "org";
|
|
465
|
+
}>;
|
|
466
|
+
lens: z.ZodEnum<{
|
|
467
|
+
true: "true";
|
|
468
|
+
complete: "complete";
|
|
469
|
+
safe: "safe";
|
|
470
|
+
ship: "ship";
|
|
471
|
+
business: "business";
|
|
472
|
+
architecture: "architecture";
|
|
473
|
+
story: "story";
|
|
474
|
+
ux: "ux";
|
|
475
|
+
delivery: "delivery";
|
|
476
|
+
"code-and-test": "code-and-test";
|
|
477
|
+
release: "release";
|
|
478
|
+
}>;
|
|
479
|
+
severity: z.ZodEnum<{
|
|
480
|
+
blocking: "blocking";
|
|
481
|
+
gap: "gap";
|
|
482
|
+
risk: "risk";
|
|
483
|
+
idea: "idea";
|
|
484
|
+
}>;
|
|
485
|
+
artifact: z.ZodString;
|
|
486
|
+
locator: z.ZodObject<{
|
|
487
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
488
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
489
|
+
record: z.ZodOptional<z.ZodString>;
|
|
490
|
+
field: z.ZodOptional<z.ZodString>;
|
|
491
|
+
}, z.core.$strict>;
|
|
492
|
+
summary: z.ZodString;
|
|
493
|
+
why: z.ZodString;
|
|
494
|
+
fix: z.ZodObject<{
|
|
495
|
+
text: z.ZodString;
|
|
496
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
497
|
+
}, z.core.$strict>;
|
|
498
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
499
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
500
|
+
code: "code";
|
|
501
|
+
config: "config";
|
|
502
|
+
spec: "spec";
|
|
503
|
+
gateway: "gateway";
|
|
504
|
+
"event-config": "event-config";
|
|
505
|
+
infrastructure: "infrastructure";
|
|
506
|
+
pipeline: "pipeline";
|
|
507
|
+
migration: "migration";
|
|
508
|
+
diagram: "diagram";
|
|
509
|
+
document: "document";
|
|
510
|
+
export: "export";
|
|
511
|
+
manual: "manual";
|
|
512
|
+
}>, z.ZodEnum<{
|
|
513
|
+
catalog: "catalog";
|
|
514
|
+
artifact: "artifact";
|
|
515
|
+
rule: "rule";
|
|
516
|
+
}>]>;
|
|
517
|
+
record: z.ZodOptional<z.ZodString>;
|
|
518
|
+
path: z.ZodOptional<z.ZodString>;
|
|
519
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
520
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
521
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
522
|
+
}, z.core.$strict>>;
|
|
523
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
524
|
+
text: z.ZodString;
|
|
525
|
+
owner: z.ZodString;
|
|
526
|
+
}, z.core.$strict>>;
|
|
527
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
528
|
+
question: z.ZodString;
|
|
529
|
+
quote: z.ZodString;
|
|
530
|
+
}, z.core.$strict>>;
|
|
531
|
+
waivable: z.ZodBoolean;
|
|
532
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
533
|
+
open: "open";
|
|
534
|
+
applied: "applied";
|
|
535
|
+
dismissed: "dismissed";
|
|
536
|
+
waived: "waived";
|
|
537
|
+
asked: "asked";
|
|
538
|
+
}>>;
|
|
539
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
540
|
+
action: z.ZodEnum<{
|
|
541
|
+
apply: "apply";
|
|
542
|
+
"edit-and-apply": "edit-and-apply";
|
|
543
|
+
"not-relevant": "not-relevant";
|
|
544
|
+
waive: "waive";
|
|
545
|
+
ask: "ask";
|
|
546
|
+
}>;
|
|
547
|
+
by: z.ZodString;
|
|
548
|
+
at: z.ZodISODateTime;
|
|
549
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
550
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
551
|
+
}, z.core.$strict>>;
|
|
552
|
+
createdAt: z.ZodISODateTime;
|
|
553
|
+
}, z.core.$strict>;
|
|
554
|
+
export type Finding = z.infer<typeof Finding>;
|
|
555
|
+
/** Where a finding's file lives inside the change folder. */
|
|
556
|
+
export declare function findingPath(f: Pick<Finding, "gate" | "round" | "id">): string;
|
|
557
|
+
/** True if text parses as a template (re-exported for org-pack tooling). */
|
|
558
|
+
export declare function isValidTemplate(t: string): boolean;
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
/**
|
|
3
|
+
* Scan settings for one repo (ADR 0075, C6): org-pack/scan/<repo>.yaml. Facts about the repo a
|
|
4
|
+
* built-in reader can't know in general, each citing the file and line it comes from: folders
|
|
5
|
+
* that aren't the product, path prefixes in front of its HTTP entry points, and base URLs in
|
|
6
|
+
* front of the HTTP calls its clients make (ADR 0076). Drafted by the
|
|
7
|
+
* AI (atticus scan survey), checked against the code, reviewed like any org-pack change.
|
|
8
|
+
*/
|
|
9
|
+
export declare const SCAN_SETTINGS_SCHEMA_VERSION: 1;
|
|
10
|
+
export declare const ScanSettings: z.ZodObject<{
|
|
11
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
12
|
+
repo: z.ZodString;
|
|
13
|
+
exclude: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
14
|
+
path: z.ZodString;
|
|
15
|
+
why: z.ZodString;
|
|
16
|
+
at: z.ZodString;
|
|
17
|
+
}, z.core.$strict>>>;
|
|
18
|
+
prefixes: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
19
|
+
paths: z.ZodArray<z.ZodString>;
|
|
20
|
+
prefix: z.ZodString;
|
|
21
|
+
why: z.ZodString;
|
|
22
|
+
at: z.ZodString;
|
|
23
|
+
value: z.ZodString;
|
|
24
|
+
}, z.core.$strict>>>;
|
|
25
|
+
clients: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
26
|
+
paths: z.ZodArray<z.ZodString>;
|
|
27
|
+
base: z.ZodString;
|
|
28
|
+
names: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
29
|
+
why: z.ZodString;
|
|
30
|
+
at: z.ZodString;
|
|
31
|
+
value: z.ZodString;
|
|
32
|
+
}, z.core.$strict>>>;
|
|
33
|
+
}, z.core.$strict>;
|
|
34
|
+
export type ScanSettings = z.infer<typeof ScanSettings>;
|