@open-tomato/rafa 0.45.0 → 0.47.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +285 -23
- package/dist/PROMPT.md +18 -1
- package/dist/adapters/logger/settings.d.ts +132 -0
- package/dist/bugs/closest.d.ts +19 -0
- package/dist/bugs/fenced.d.ts +8 -0
- package/dist/bugs/places.d.ts +20 -0
- package/dist/bugs/record.d.ts +145 -0
- package/dist/bugs/title.d.ts +83 -0
- package/dist/bundled/agents/doc-updater.md +17 -3
- package/dist/bundled/agents/loop-implementer.md +14 -2
- package/dist/bundled/operators/skills/rafa-stretch-pit-stop/SKILL.md +10 -3
- package/dist/bundled/operators/skills/rafa-stretch-sweep/SKILL.md +5 -0
- package/dist/bundled/skills/dev-planner/SKILL.md +101 -18
- package/dist/cli.js +76536 -64285
- package/dist/config/entry.d.ts +119 -0
- package/dist/config/index.d.ts +41 -0
- package/dist/config/index.js +54 -0
- package/dist/config/shape.d.ts +235 -0
- package/dist/config/templates.d.ts +64 -0
- package/dist/config-registry.d.ts +136 -0
- package/dist/config-schema-board-project.d.ts +157 -0
- package/dist/config-schema-bugs.d.ts +71 -0
- package/dist/config-schema-checks.d.ts +114 -0
- package/dist/config-schema-errors.d.ts +54 -0
- package/dist/config-schema-features.d.ts +64 -0
- package/dist/config-schema-hub.d.ts +152 -0
- package/dist/config-schema-issues.d.ts +95 -0
- package/dist/config-schema-logger.d.ts +91 -0
- package/dist/config-schema-loop-continue.d.ts +122 -0
- package/dist/config-schema-loop-retries.d.ts +94 -0
- package/dist/config-schema-release.d.ts +306 -0
- package/dist/config-schema-tests.d.ts +178 -0
- package/dist/config-schema-triage.d.ts +142 -0
- package/dist/config-schema-wrap-up.d.ts +96 -0
- package/dist/core/command/command.d.ts +228 -0
- package/dist/core/command/confirm.d.ts +73 -0
- package/dist/core/command/index.d.ts +130 -0
- package/dist/core/command/lazy.d.ts +54 -0
- package/dist/core/command/registry-types.d.ts +96 -0
- package/dist/core/command/running.d.ts +96 -0
- package/dist/core/command/shared-flags.d.ts +40 -0
- package/dist/core/command/spends.d.ts +39 -0
- package/dist/core/command/types.d.ts +92 -0
- package/dist/core/command/version.d.ts +4 -0
- package/dist/core/config/branch-template.d.ts +20 -0
- package/dist/core/config/config-items.d.ts +86 -0
- package/dist/core/config/config-load-module.d.ts +43 -0
- package/dist/core/config/config-load.d.ts +78 -0
- package/dist/core/config/config-origins.d.ts +58 -0
- package/dist/core/config/config-readers.d.ts +167 -0
- package/dist/core/config/config-schema.d.ts +212 -0
- package/dist/core/config/config-sections.d.ts +493 -0
- package/dist/core/config/config.d.ts +385 -0
- package/dist/core/config/core-section.d.ts +39 -0
- package/dist/core/config/dangerous.d.ts +58 -0
- package/dist/core/config/default-routing.d.ts +16 -0
- package/dist/core/config/index.d.ts +145 -0
- package/dist/core/config/merge-method.d.ts +40 -0
- package/dist/core/config/scope.d.ts +42 -0
- package/dist/core/config/section.d.ts +286 -0
- package/dist/core/config/sections.d.ts +53 -0
- package/dist/core/config/standard-schema.d.ts +27 -0
- package/dist/core/git/commit.d.ts +232 -0
- package/dist/core/git/gh-runner.d.ts +24 -0
- package/dist/core/git/git.d.ts +22 -0
- package/dist/core/git/index.d.ts +85 -0
- package/dist/core/loop/claude.d.ts +388 -0
- package/dist/core/loop/hop-record.d.ts +52 -0
- package/dist/core/loop/index.d.ts +179 -0
- package/dist/core/loop/session-env.d.ts +20 -0
- package/dist/core/loop/session-record-parse.d.ts +70 -0
- package/dist/core/loop/sessions.d.ts +420 -0
- package/dist/core/loop/suite-failure.d.ts +25 -0
- package/dist/core/output/active.d.ts +100 -0
- package/dist/core/output/stream.d.ts +20 -0
- package/dist/core/output/text.d.ts +55 -0
- package/dist/core/plan/block-reader.d.ts +46 -0
- package/dist/core/plan/blocks.d.ts +139 -0
- package/dist/core/plan/declaration.d.ts +366 -0
- package/dist/core/plan/plan-stamp.d.ts +75 -0
- package/dist/core/runtime/identity.d.ts +21 -0
- package/dist/core/runtime/index.d.ts +46 -0
- package/dist/effort/store/bring-forward.d.ts +131 -0
- package/dist/effort/store/check-rows.d.ts +31 -0
- package/dist/effort/store/commit-stats.d.ts +42 -0
- package/dist/effort/store/copy.d.ts +35 -0
- package/dist/effort/store/development-build.d.ts +105 -0
- package/dist/effort/store/effort-levels.d.ts +13 -0
- package/dist/effort/store/findings.d.ts +214 -0
- package/dist/effort/store/fix-schema.d.ts +184 -0
- package/dist/effort/store/index.js +10 -7
- package/dist/effort/store/location.d.ts +44 -0
- package/dist/effort/store/merge-commit-gaps.d.ts +68 -0
- package/dist/effort/store/merge-conflicts.d.ts +91 -0
- package/dist/effort/store/merge-rules.d.ts +82 -0
- package/dist/effort/store/merge-store.d.ts +211 -0
- package/dist/effort/store/merge-union.d.ts +92 -0
- package/dist/effort/store/migrate.d.ts +146 -0
- package/dist/effort/store/migrations.d.ts +92 -0
- package/dist/effort/store/ndjson-files.d.ts +114 -0
- package/dist/effort/store/origins.d.ts +116 -0
- package/dist/effort/store/plan-stubs.d.ts +79 -0
- package/dist/effort/store/rebuild-aside.d.ts +172 -0
- package/dist/effort/store/schema-plan.d.ts +102 -0
- package/dist/effort/store/session-row-types.d.ts +64 -0
- package/dist/effort/store/settings.d.ts +13 -0
- package/dist/effort/store/sqlite.d.ts +340 -0
- package/dist/effort/store/store-generation.d.ts +17 -0
- package/dist/effort/store/store-identity.d.ts +220 -0
- package/dist/effort/store/store-meta.d.ts +305 -0
- package/dist/effort/store/store-replaced.d.ts +72 -0
- package/dist/effort/store/types.d.ts +223 -0
- package/dist/errors/codes.d.ts +56 -0
- package/dist/errors/rafa-codes.d.ts +36 -0
- package/dist/{index-nv34ptht.js → index-38ktnyvz.js} +14 -9
- package/dist/index-3mwsr6wg.js +1070 -0
- package/dist/index-7dgc5g1t.js +13480 -0
- package/dist/index-cbqvgda6.js +766 -0
- package/dist/index-eay1bd2w.js +2632 -0
- package/dist/index-f1y86zbb.js +125 -0
- package/dist/index-n3e31fmw.js +1041 -0
- package/dist/{index-r28fzsvc.js → index-nwzx41g1.js} +351 -166
- package/dist/index-pzpb1rf7.js +153 -0
- package/dist/{index-mgh2s9bj.js → index-r5q2pdky.js} +65 -457
- package/dist/index-z1w83f81.js +4 -0
- package/dist/index.js +17592 -24119
- package/dist/learning/index.js +5 -6
- package/dist/plan/index.js +12 -11
- package/dist/plan-prompt.md +3 -1
- package/dist/ports/index.d.ts +732 -0
- package/dist/ports/learning.d.ts +101 -0
- package/dist/ports/log-level.d.ts +13 -0
- package/dist/ports/spec-review.d.ts +66 -0
- package/dist/ready-6p40c3gw.js +2007 -0
- package/dist/release-templates/release-bot-fragment.yml +153 -0
- package/dist/release-templates/release-publish.yml +110 -0
- package/dist/release-templates/release-settle.yml +122 -0
- package/dist/release-templates/release-tag.yml +102 -0
- package/dist/report/parse.d.ts +415 -0
- package/dist/schema/project-id.d.ts +79 -0
- package/dist/schema/tiers.d.ts +107 -0
- package/package.json +62 -3
- package/dist/index-hf2k497d.js +0 -16
- package/dist/index-nsr78ct2.js +0 -8219
|
@@ -0,0 +1,1041 @@
|
|
|
1
|
+
// @bun
|
|
2
|
+
import {
|
|
3
|
+
DEFAULT_LOGGER_KIND,
|
|
4
|
+
ERROR_LEVELS,
|
|
5
|
+
LOGGER_THEMES,
|
|
6
|
+
LOG_LEVELS,
|
|
7
|
+
RAFA_CODES,
|
|
8
|
+
codeProblem,
|
|
9
|
+
listedCodes,
|
|
10
|
+
setActiveLoggerSettings
|
|
11
|
+
} from "./index-pzpb1rf7.js";
|
|
12
|
+
import {
|
|
13
|
+
CORE_SECTION,
|
|
14
|
+
activeSettings,
|
|
15
|
+
registerConfigSections,
|
|
16
|
+
setConfigLoadHook,
|
|
17
|
+
setConfigTemplateHook
|
|
18
|
+
} from "./index-cbqvgda6.js";
|
|
19
|
+
import {
|
|
20
|
+
MERGE_METHODS,
|
|
21
|
+
PR_PROVIDERS,
|
|
22
|
+
RELEASE_AUTO,
|
|
23
|
+
below,
|
|
24
|
+
describeValue,
|
|
25
|
+
flag,
|
|
26
|
+
fragmentsDirectory,
|
|
27
|
+
isMapping,
|
|
28
|
+
listOf,
|
|
29
|
+
mapOf,
|
|
30
|
+
oneOf,
|
|
31
|
+
refused,
|
|
32
|
+
refusedWith,
|
|
33
|
+
releaseEnabled,
|
|
34
|
+
releaseFile,
|
|
35
|
+
releasePublishMode,
|
|
36
|
+
releaseSettleMode,
|
|
37
|
+
releaseStrategy,
|
|
38
|
+
releaseTagMode,
|
|
39
|
+
text,
|
|
40
|
+
usdAmount,
|
|
41
|
+
versionCollisionMode
|
|
42
|
+
} from "./index-r5q2pdky.js";
|
|
43
|
+
|
|
44
|
+
// src/config/templates.ts
|
|
45
|
+
function frozen(value) {
|
|
46
|
+
if (typeof value !== "object" || value === null)
|
|
47
|
+
return value;
|
|
48
|
+
Object.values(value).forEach(frozen);
|
|
49
|
+
return Object.freeze(value);
|
|
50
|
+
}
|
|
51
|
+
var ESCALATION = frozen({
|
|
52
|
+
tests: {
|
|
53
|
+
fullSuiteTriggers: ["bunfig.toml", "tsconfig*.json", "package.json", "bun.lock", "bun.lockb"],
|
|
54
|
+
integration: [
|
|
55
|
+
"**/*-integration.test.ts",
|
|
56
|
+
"**/*.integration.test.ts",
|
|
57
|
+
"**/*-spawned*.test.ts",
|
|
58
|
+
"**/*-cli.test.ts"
|
|
59
|
+
],
|
|
60
|
+
contract: ["**/*.contract.test.ts"]
|
|
61
|
+
},
|
|
62
|
+
checks: {
|
|
63
|
+
task: ["affected"],
|
|
64
|
+
stage: ["related", "integration"],
|
|
65
|
+
loop: ["full"]
|
|
66
|
+
}
|
|
67
|
+
});
|
|
68
|
+
var CONFIG_TEMPLATES = Object.freeze({
|
|
69
|
+
escalation: ESCALATION
|
|
70
|
+
});
|
|
71
|
+
var TEMPLATE_NAMES = Object.freeze(Object.keys(CONFIG_TEMPLATES));
|
|
72
|
+
var templateEntry = Object.freeze(Object.assign((name) => Object.hasOwn(CONFIG_TEMPLATES, name) ? CONFIG_TEMPLATES[name] : null, { names: TEMPLATE_NAMES }));
|
|
73
|
+
|
|
74
|
+
// packages/rafa/src/config-schema-bugs.ts
|
|
75
|
+
var BUGS_RECHECK_RUNS_MIN = 1;
|
|
76
|
+
var BUGS_RECHECK_RUNS_MAX = 20;
|
|
77
|
+
var BUGS_RECHECK_TIMEOUT_MIN = 1;
|
|
78
|
+
var BUGS_RECHECK_TIMEOUT_MAX = 3600;
|
|
79
|
+
function wholeNumberIn(min, max) {
|
|
80
|
+
return (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= min && raw <= max ? { value: raw, problems: [], extras: [] } : refused(at, raw, `a whole number from ${String(min)} to ${String(max)}`);
|
|
81
|
+
}
|
|
82
|
+
var bugsRecheckRuns = wholeNumberIn(BUGS_RECHECK_RUNS_MIN, BUGS_RECHECK_RUNS_MAX);
|
|
83
|
+
var bugsRecheckTimeoutSeconds = wholeNumberIn(BUGS_RECHECK_TIMEOUT_MIN, BUGS_RECHECK_TIMEOUT_MAX);
|
|
84
|
+
var BUGS_DEFAULTS = Object.freeze({
|
|
85
|
+
bugsRecheckRuns: 5,
|
|
86
|
+
bugsRecheckTimeoutSeconds: 300
|
|
87
|
+
});
|
|
88
|
+
var BUGS_SETTINGS = {
|
|
89
|
+
bugsRecheckRuns: { key: "bugs.recheck.runs", read: bugsRecheckRuns, cli: false },
|
|
90
|
+
bugsRecheckTimeoutSeconds: { key: "bugs.recheck.timeoutSeconds", read: bugsRecheckTimeoutSeconds, cli: false }
|
|
91
|
+
};
|
|
92
|
+
var BUGS_SECTION = Object.freeze({
|
|
93
|
+
package: "bugs",
|
|
94
|
+
settings: Object.freeze(BUGS_SETTINGS),
|
|
95
|
+
defaults: BUGS_DEFAULTS
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
// packages/rafa/src/config-schema-errors.ts
|
|
99
|
+
var ERROR_CODE_KEYS = ["code", "description", "hint", "level", "since"];
|
|
100
|
+
var KNOWN_KEYS = new Set(ERROR_CODE_KEYS);
|
|
101
|
+
var ERRORS_DEFAULTS = Object.freeze({ errorsCodes: Object.freeze([]) });
|
|
102
|
+
var codeText = (raw, at) => {
|
|
103
|
+
const read = text("a code, <family>:<leaf>")(raw, at);
|
|
104
|
+
if (read.value === undefined)
|
|
105
|
+
return read;
|
|
106
|
+
const fault = codeProblem(read.value);
|
|
107
|
+
return fault === null ? read : refused(at, raw, `a code: ${fault}`);
|
|
108
|
+
};
|
|
109
|
+
var EXPECTED = {
|
|
110
|
+
description: "a one-line description, a non-empty string",
|
|
111
|
+
hint: "the next action, a non-empty string",
|
|
112
|
+
since: "the version or issue that added it, a non-empty string"
|
|
113
|
+
};
|
|
114
|
+
var NO_SINCE = { value: undefined, problems: [], extras: [] };
|
|
115
|
+
var errorCodeEntry = (raw, at) => {
|
|
116
|
+
if (!isMapping(raw))
|
|
117
|
+
return refused(at, raw, `a mapping of: ${ERROR_CODE_KEYS.join(", ")}`);
|
|
118
|
+
const code = codeText(raw.code, below(at, ".code"));
|
|
119
|
+
const description = text(EXPECTED.description)(raw.description, below(at, ".description"));
|
|
120
|
+
const hint = text(EXPECTED.hint)(raw.hint, below(at, ".hint"));
|
|
121
|
+
const level = oneOf(ERROR_LEVELS)(raw.level, below(at, ".level"));
|
|
122
|
+
const since = raw.since === undefined || raw.since === null ? NO_SINCE : text(EXPECTED.since)(raw.since, below(at, ".since"));
|
|
123
|
+
const problems = [code, description, hint, level, since].flatMap((reading) => reading.problems);
|
|
124
|
+
const extras = Object.entries(raw).filter(([key]) => !KNOWN_KEYS.has(key)).map(([key, value]) => ({ key: `${at.key}.${key}`, value }));
|
|
125
|
+
if (code.value === undefined || description.value === undefined || hint.value === undefined || level.value === undefined || problems.length > 0)
|
|
126
|
+
return { value: undefined, problems, extras };
|
|
127
|
+
const entry = {
|
|
128
|
+
code: code.value,
|
|
129
|
+
description: description.value,
|
|
130
|
+
hint: hint.value,
|
|
131
|
+
level: level.value,
|
|
132
|
+
...since.value === undefined ? {} : { since: since.value }
|
|
133
|
+
};
|
|
134
|
+
return { value: Object.freeze(entry), problems: [], extras };
|
|
135
|
+
};
|
|
136
|
+
var errorCodes = (raw, at) => {
|
|
137
|
+
const read = listOf(errorCodeEntry, "error code entries")(raw, at);
|
|
138
|
+
const entries = read.value;
|
|
139
|
+
if (entries === undefined)
|
|
140
|
+
return read;
|
|
141
|
+
const problems = entries.flatMap((entry, index) => {
|
|
142
|
+
const label = `${below(at, `[${index}]`).label}.code is ${JSON.stringify(entry.code)}`;
|
|
143
|
+
if (RAFA_CODES.some((own) => own.code === entry.code)) {
|
|
144
|
+
return [`${label}, which rafa already declares; add a leaf of your own instead`];
|
|
145
|
+
}
|
|
146
|
+
const first = entries.findIndex((other) => other.code === entry.code);
|
|
147
|
+
return first < index ? [`${label}, already given at [${first}]`] : [];
|
|
148
|
+
});
|
|
149
|
+
return problems.length === 0 ? read : { ...refusedWith(problems), extras: read.extras };
|
|
150
|
+
};
|
|
151
|
+
var ERRORS_SETTINGS = {
|
|
152
|
+
errorsCodes: { key: "errors.codes", read: errorCodes, cli: false, itemKeys: ERROR_CODE_KEYS }
|
|
153
|
+
};
|
|
154
|
+
var ERRORS_SECTION = Object.freeze({
|
|
155
|
+
package: "errors",
|
|
156
|
+
settings: Object.freeze(ERRORS_SETTINGS),
|
|
157
|
+
defaults: ERRORS_DEFAULTS
|
|
158
|
+
});
|
|
159
|
+
|
|
160
|
+
// packages/rafa/src/config-schema-features.ts
|
|
161
|
+
var FEATURES_DEFAULTS = Object.freeze({
|
|
162
|
+
featuresBoard: true,
|
|
163
|
+
featuresPr: true,
|
|
164
|
+
featuresRun: true,
|
|
165
|
+
featuresRelease: true
|
|
166
|
+
});
|
|
167
|
+
var FEATURES_SETTINGS = {
|
|
168
|
+
featuresBoard: { key: "features.board", read: flag, cli: false },
|
|
169
|
+
featuresPr: { key: "features.pr", read: flag, cli: false },
|
|
170
|
+
featuresRun: { key: "features.run", read: flag, cli: false },
|
|
171
|
+
featuresRelease: { key: "features.release", read: flag, cli: false }
|
|
172
|
+
};
|
|
173
|
+
var FEATURES_SECTION = Object.freeze({
|
|
174
|
+
package: "features",
|
|
175
|
+
settings: Object.freeze(FEATURES_SETTINGS),
|
|
176
|
+
defaults: FEATURES_DEFAULTS
|
|
177
|
+
});
|
|
178
|
+
|
|
179
|
+
// packages/rafa/src/config-schema-logger.ts
|
|
180
|
+
var MODULE_LEVEL_KEY = "level";
|
|
181
|
+
var MODULE_EXPECTED = `a mapping holding ${MODULE_LEVEL_KEY}`;
|
|
182
|
+
var moduleLevel = (raw, at) => {
|
|
183
|
+
if (!isMapping(raw))
|
|
184
|
+
return refused(at, raw, MODULE_EXPECTED);
|
|
185
|
+
const level = oneOf(LOG_LEVELS)(raw[MODULE_LEVEL_KEY], below(at, `.${MODULE_LEVEL_KEY}`));
|
|
186
|
+
const extras = Object.entries(raw).filter(([key]) => key !== MODULE_LEVEL_KEY).map(([key, value]) => ({ key: `${at.key}.${key}`, value }));
|
|
187
|
+
return { ...level, extras };
|
|
188
|
+
};
|
|
189
|
+
var LOGGER_DEFAULTS = Object.freeze({
|
|
190
|
+
loggerKind: DEFAULT_LOGGER_KIND,
|
|
191
|
+
loggerLevel: "warn",
|
|
192
|
+
loggerTheme: "default",
|
|
193
|
+
loggerModules: new Map,
|
|
194
|
+
loggerCallSite: false,
|
|
195
|
+
loggerApi: false
|
|
196
|
+
});
|
|
197
|
+
var LOGGER_SETTINGS = {
|
|
198
|
+
loggerKind: { key: "logger.kind", read: text("an adapter kind, such as console"), cli: false },
|
|
199
|
+
loggerLevel: { key: "logger.level", read: oneOf(LOG_LEVELS), cli: false },
|
|
200
|
+
loggerTheme: { key: "logger.theme", read: oneOf(LOGGER_THEMES), cli: false },
|
|
201
|
+
loggerModules: { key: "logger.modules", read: mapOf(moduleLevel, MODULE_EXPECTED), cli: false, map: true },
|
|
202
|
+
loggerCallSite: { key: "logger.callSite", read: flag, cli: false },
|
|
203
|
+
loggerApi: { key: "logger.api", read: flag, cli: false }
|
|
204
|
+
};
|
|
205
|
+
var LOGGER_SECTION = Object.freeze({
|
|
206
|
+
package: "logger",
|
|
207
|
+
settings: Object.freeze(LOGGER_SETTINGS),
|
|
208
|
+
defaults: LOGGER_DEFAULTS
|
|
209
|
+
});
|
|
210
|
+
function loggerSettingsOf(config) {
|
|
211
|
+
return {
|
|
212
|
+
kind: config.loggerKind,
|
|
213
|
+
level: config.loggerLevel,
|
|
214
|
+
theme: config.loggerTheme,
|
|
215
|
+
modules: config.loggerModules,
|
|
216
|
+
callSite: config.loggerCallSite,
|
|
217
|
+
api: config.loggerApi
|
|
218
|
+
};
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
// src/config-schema-board-project.ts
|
|
222
|
+
var BOARD_PROJECT_RETRIES_MIN = 1;
|
|
223
|
+
var BOARD_PROJECT_RETRIES_MAX = 10;
|
|
224
|
+
var BOARD_PROJECT_RETRY_WAIT_MIN_SECONDS = 1;
|
|
225
|
+
var BOARD_PROJECT_RETRY_WAIT_MAX_SECONDS = 60;
|
|
226
|
+
var BOARD_PROJECT_PROGRESS_MIN_SECONDS = 1;
|
|
227
|
+
var BOARD_PROJECT_PROGRESS_MAX_SECONDS = 300;
|
|
228
|
+
var BOARD_PROJECT_WRITE_BATCH_MIN = 1;
|
|
229
|
+
var BOARD_PROJECT_WRITE_BATCH_MAX = 100;
|
|
230
|
+
var BOARD_PROJECT_WRITE_PAUSE_MIN_MS = 0;
|
|
231
|
+
var BOARD_PROJECT_WRITE_PAUSE_MAX_MS = 60000;
|
|
232
|
+
function isWholeBetween(raw, min, max) {
|
|
233
|
+
return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= min && raw <= max;
|
|
234
|
+
}
|
|
235
|
+
function rangeWords(min, max) {
|
|
236
|
+
return `a whole number from ${String(min)} to ${String(max)}`;
|
|
237
|
+
}
|
|
238
|
+
function wholeBetween(min, max) {
|
|
239
|
+
return (raw, at) => isWholeBetween(raw, min, max) ? { value: raw, problems: [], extras: [] } : refused(at, raw, rangeWords(min, max));
|
|
240
|
+
}
|
|
241
|
+
function offOrWholeBetween(min, max) {
|
|
242
|
+
return (raw, at) => raw === false || isWholeBetween(raw, min, max) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or ${rangeWords(min, max)}`);
|
|
243
|
+
}
|
|
244
|
+
var boardProjectRetries = offOrWholeBetween(BOARD_PROJECT_RETRIES_MIN, BOARD_PROJECT_RETRIES_MAX);
|
|
245
|
+
var boardProjectRetryWaitSeconds = wholeBetween(BOARD_PROJECT_RETRY_WAIT_MIN_SECONDS, BOARD_PROJECT_RETRY_WAIT_MAX_SECONDS);
|
|
246
|
+
var boardProjectProgressSeconds = offOrWholeBetween(BOARD_PROJECT_PROGRESS_MIN_SECONDS, BOARD_PROJECT_PROGRESS_MAX_SECONDS);
|
|
247
|
+
var boardProjectWriteBatchSize = wholeBetween(BOARD_PROJECT_WRITE_BATCH_MIN, BOARD_PROJECT_WRITE_BATCH_MAX);
|
|
248
|
+
var boardProjectWritePauseMs = wholeBetween(BOARD_PROJECT_WRITE_PAUSE_MIN_MS, BOARD_PROJECT_WRITE_PAUSE_MAX_MS);
|
|
249
|
+
var BOARD_PROJECT_LIMIT_DEFAULTS = Object.freeze({
|
|
250
|
+
boardProjectRetries: 3,
|
|
251
|
+
boardProjectRetryWaitSeconds: 2,
|
|
252
|
+
boardProjectProgressSeconds: 10,
|
|
253
|
+
boardProjectWriteBatchSize: 20,
|
|
254
|
+
boardProjectWritePauseMs: 1000
|
|
255
|
+
});
|
|
256
|
+
var BOARD_PROJECT_LIMIT_SETTINGS = {
|
|
257
|
+
boardProjectRetries: { key: "board.project.retries", read: boardProjectRetries, cli: false },
|
|
258
|
+
boardProjectRetryWaitSeconds: {
|
|
259
|
+
key: "board.project.retryWaitSeconds",
|
|
260
|
+
read: boardProjectRetryWaitSeconds,
|
|
261
|
+
cli: false
|
|
262
|
+
},
|
|
263
|
+
boardProjectProgressSeconds: {
|
|
264
|
+
key: "board.project.progressSeconds",
|
|
265
|
+
read: boardProjectProgressSeconds,
|
|
266
|
+
cli: false
|
|
267
|
+
},
|
|
268
|
+
boardProjectWriteBatchSize: {
|
|
269
|
+
key: "board.project.writeBatchSize",
|
|
270
|
+
read: boardProjectWriteBatchSize,
|
|
271
|
+
cli: false
|
|
272
|
+
},
|
|
273
|
+
boardProjectWritePauseMs: {
|
|
274
|
+
key: "board.project.writePauseMs",
|
|
275
|
+
read: boardProjectWritePauseMs,
|
|
276
|
+
cli: false
|
|
277
|
+
}
|
|
278
|
+
};
|
|
279
|
+
var BOARD_PROJECT_SECTION = Object.freeze({
|
|
280
|
+
package: "board-project",
|
|
281
|
+
settings: Object.freeze(BOARD_PROJECT_LIMIT_SETTINGS),
|
|
282
|
+
defaults: BOARD_PROJECT_LIMIT_DEFAULTS
|
|
283
|
+
});
|
|
284
|
+
|
|
285
|
+
// src/config-schema-checks.ts
|
|
286
|
+
var CHECK_NAMES = Object.freeze([
|
|
287
|
+
"affected",
|
|
288
|
+
"related",
|
|
289
|
+
"unit",
|
|
290
|
+
"contract",
|
|
291
|
+
"integration",
|
|
292
|
+
"full"
|
|
293
|
+
]);
|
|
294
|
+
var EXPECTED2 = `a list of check names, each at most once, from: ${CHECK_NAMES.join(", ")}`;
|
|
295
|
+
var namesList = listOf(oneOf(CHECK_NAMES), `check names from: ${CHECK_NAMES.join(", ")}`);
|
|
296
|
+
var checkList = (raw, at) => {
|
|
297
|
+
const reading = namesList(raw, at);
|
|
298
|
+
if (reading.value === undefined)
|
|
299
|
+
return reading;
|
|
300
|
+
const repeated = reading.value.find((name, index) => reading.value?.indexOf(name) !== index);
|
|
301
|
+
return repeated === undefined ? reading : refused(at, raw, `${EXPECTED2}; ${JSON.stringify(repeated)} is written twice`);
|
|
302
|
+
};
|
|
303
|
+
var NO_CHECKS = Object.freeze([]);
|
|
304
|
+
var CHECKS_DEFAULTS = Object.freeze({
|
|
305
|
+
checksTask: NO_CHECKS,
|
|
306
|
+
checksStage: NO_CHECKS,
|
|
307
|
+
checksLoop: NO_CHECKS,
|
|
308
|
+
checksPullRequest: NO_CHECKS,
|
|
309
|
+
checksStretch: NO_CHECKS,
|
|
310
|
+
checksReleasePullRequest: NO_CHECKS,
|
|
311
|
+
checksPublish: NO_CHECKS
|
|
312
|
+
});
|
|
313
|
+
var CHECKS_SETTINGS = {
|
|
314
|
+
checksTask: { key: "checks.task", read: checkList, cli: false },
|
|
315
|
+
checksStage: { key: "checks.stage", read: checkList, cli: false },
|
|
316
|
+
checksLoop: { key: "checks.loop", read: checkList, cli: false },
|
|
317
|
+
checksPullRequest: { key: "checks.pullRequest", read: checkList, cli: false },
|
|
318
|
+
checksStretch: { key: "checks.stretch", read: checkList, cli: false },
|
|
319
|
+
checksReleasePullRequest: { key: "checks.releasePullRequest", read: checkList, cli: false },
|
|
320
|
+
checksPublish: { key: "checks.publish", read: checkList, cli: false }
|
|
321
|
+
};
|
|
322
|
+
var CHECKS_SECTION = Object.freeze({
|
|
323
|
+
package: "checks",
|
|
324
|
+
settings: Object.freeze(CHECKS_SETTINGS),
|
|
325
|
+
defaults: CHECKS_DEFAULTS
|
|
326
|
+
});
|
|
327
|
+
|
|
328
|
+
// src/config-schema-hub.ts
|
|
329
|
+
var HUB_TIMEOUT_MIN_SECONDS = 1;
|
|
330
|
+
var HUB_TIMEOUT_MAX_SECONDS = 30;
|
|
331
|
+
var MS_PER_SECOND = 1000;
|
|
332
|
+
var HUB_TIMEOUT = /^(\d+)s$/;
|
|
333
|
+
var HUB_URL_PROTOCOLS = Object.freeze(["http:", "https:"]);
|
|
334
|
+
var HUB_DEFAULTS = Object.freeze({
|
|
335
|
+
hubUrl: null,
|
|
336
|
+
hubTokenSecret: null,
|
|
337
|
+
hubTimeout: "3s"
|
|
338
|
+
});
|
|
339
|
+
function hubTimeoutMs(raw) {
|
|
340
|
+
const match = typeof raw === "string" ? HUB_TIMEOUT.exec(raw) : null;
|
|
341
|
+
if (match === null)
|
|
342
|
+
return null;
|
|
343
|
+
const seconds = Number(match[1]);
|
|
344
|
+
return seconds >= HUB_TIMEOUT_MIN_SECONDS && seconds <= HUB_TIMEOUT_MAX_SECONDS ? seconds * MS_PER_SECOND : null;
|
|
345
|
+
}
|
|
346
|
+
var hubTimeout = (raw, at) => hubTimeoutMs(raw) === null ? refused(at, raw, `a duration of whole seconds from ${String(HUB_TIMEOUT_MIN_SECONDS)}s to ${String(HUB_TIMEOUT_MAX_SECONDS)}s, such as 3s`) : { value: raw, problems: [], extras: [] };
|
|
347
|
+
function isHubUrl(raw) {
|
|
348
|
+
if (typeof raw !== "string" || raw.trim() !== raw)
|
|
349
|
+
return false;
|
|
350
|
+
const url = URL.parse(raw);
|
|
351
|
+
return url !== null && HUB_URL_PROTOCOLS.includes(url.protocol) && url.username === "" && url.password === "";
|
|
352
|
+
}
|
|
353
|
+
var hubUrl = (raw, at) => isHubUrl(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, "an http or https URL with no user name or password, such as https://hub.example.org");
|
|
354
|
+
var HUB_SETTINGS = {
|
|
355
|
+
hubUrl: { key: "hub.url", read: hubUrl, cli: false },
|
|
356
|
+
hubTokenSecret: { key: "hub.tokenSecret", read: text("a secret store name"), cli: false },
|
|
357
|
+
hubTimeout: { key: "hub.timeout", read: hubTimeout, cli: false }
|
|
358
|
+
};
|
|
359
|
+
var HUB_STRATEGY = "service";
|
|
360
|
+
function labelOf(input) {
|
|
361
|
+
return input.provenance.effortSync?.file ?? input.sources.effortSync;
|
|
362
|
+
}
|
|
363
|
+
function hubUrlProblems(input) {
|
|
364
|
+
if (input.config.effortSync !== HUB_STRATEGY || input.config.hubUrl !== null)
|
|
365
|
+
return [];
|
|
366
|
+
return [
|
|
367
|
+
`${labelOf(input)}: effort.sync is ${describeValue(HUB_STRATEGY)} and no config file names hub.url;` + " expected hub.url, the address of the hub, such as https://hub.example.org"
|
|
368
|
+
];
|
|
369
|
+
}
|
|
370
|
+
var HUB_SECTION = Object.freeze({
|
|
371
|
+
package: "hub",
|
|
372
|
+
settings: Object.freeze(HUB_SETTINGS),
|
|
373
|
+
defaults: HUB_DEFAULTS,
|
|
374
|
+
checks: Object.freeze([hubUrlProblems])
|
|
375
|
+
});
|
|
376
|
+
function hubContextOf(config) {
|
|
377
|
+
const url = config.hubUrl ?? null;
|
|
378
|
+
if (url === null)
|
|
379
|
+
return;
|
|
380
|
+
const timeout = config.hubTimeout ?? HUB_DEFAULTS.hubTimeout;
|
|
381
|
+
const timeoutMs = hubTimeoutMs(timeout);
|
|
382
|
+
if (timeoutMs === null) {
|
|
383
|
+
throw new TypeError(`hub.timeout is ${describeValue(timeout)}, which no config accepts`);
|
|
384
|
+
}
|
|
385
|
+
return Object.freeze({ url, tokenSecret: config.hubTokenSecret ?? null, timeoutMs });
|
|
386
|
+
}
|
|
387
|
+
|
|
388
|
+
// packages/rafa/src/bugs/places.ts
|
|
389
|
+
var BUILT_IN_ENVIRONMENTS = ["local", "ci", "prod"];
|
|
390
|
+
var CI_OFF = ["", "0", "false"];
|
|
391
|
+
function suggestedEnvironment(env) {
|
|
392
|
+
return CI_OFF.includes((env["CI"] ?? "").trim().toLowerCase()) ? "local" : "ci";
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
// packages/rafa/src/bugs/title.ts
|
|
396
|
+
var TITLE_VARIABLES = ["type", "project", "projectType", "module", "action", "summary"];
|
|
397
|
+
var UNKNOWN_VALUE = "unknown";
|
|
398
|
+
var DEFAULT_BUG_TITLE = "?(${module}?( - ${action}): )${summary}";
|
|
399
|
+
var MODULE_SHAPE = "[a-z0-9][a-z0-9._-]*";
|
|
400
|
+
var ACTION_SHAPE = "[a-z0-9][a-z0-9._ -]*";
|
|
401
|
+
var SUMMARY = "summary";
|
|
402
|
+
var VARIABLE_SHAPES = { module: MODULE_SHAPE, action: ACTION_SHAPE };
|
|
403
|
+
var FREE_SHAPE = ".+";
|
|
404
|
+
var GROUP_OPEN = "?(";
|
|
405
|
+
var GROUP_CLOSE = ")";
|
|
406
|
+
var VARIABLE_OPEN = "${";
|
|
407
|
+
var VARIABLE_CLOSE = "}";
|
|
408
|
+
|
|
409
|
+
class TitleTemplateError extends Error {
|
|
410
|
+
constructor(message) {
|
|
411
|
+
super(message);
|
|
412
|
+
this.name = "TitleTemplateError";
|
|
413
|
+
}
|
|
414
|
+
}
|
|
415
|
+
function isPrintable(value) {
|
|
416
|
+
return typeof value === "string" && value.trim() !== "" && value.trim() !== UNKNOWN_VALUE;
|
|
417
|
+
}
|
|
418
|
+
function isTitleVariable(name) {
|
|
419
|
+
return TITLE_VARIABLES.includes(name);
|
|
420
|
+
}
|
|
421
|
+
function readVariable(template, at) {
|
|
422
|
+
const close = template.indexOf(VARIABLE_CLOSE, at);
|
|
423
|
+
if (close === -1)
|
|
424
|
+
throw new TitleTemplateError(`"${VARIABLE_OPEN}" at ${at} is never closed`);
|
|
425
|
+
const name = template.slice(at + VARIABLE_OPEN.length, close);
|
|
426
|
+
if (!isTitleVariable(name)) {
|
|
427
|
+
throw new TitleTemplateError(`\${${name}} names no variable, expected one of: ${TITLE_VARIABLES.join(", ")}`);
|
|
428
|
+
}
|
|
429
|
+
return { node: { kind: "variable", name }, next: close + VARIABLE_CLOSE.length };
|
|
430
|
+
}
|
|
431
|
+
function readNodes(template, start, depth) {
|
|
432
|
+
const nodes = [];
|
|
433
|
+
let text2 = "";
|
|
434
|
+
let at = start;
|
|
435
|
+
const flush = () => {
|
|
436
|
+
if (text2 !== "")
|
|
437
|
+
nodes.push({ kind: "text", text: text2 });
|
|
438
|
+
text2 = "";
|
|
439
|
+
};
|
|
440
|
+
while (at < template.length) {
|
|
441
|
+
if (template.startsWith(GROUP_OPEN, at)) {
|
|
442
|
+
flush();
|
|
443
|
+
const inner = readNodes(template, at + GROUP_OPEN.length, depth + 1);
|
|
444
|
+
nodes.push({ kind: "group", nodes: inner.nodes });
|
|
445
|
+
at = inner.next;
|
|
446
|
+
} else if (depth > 0 && template[at] === GROUP_CLOSE) {
|
|
447
|
+
flush();
|
|
448
|
+
return { nodes, next: at + GROUP_CLOSE.length };
|
|
449
|
+
} else if (template.startsWith(VARIABLE_OPEN, at)) {
|
|
450
|
+
flush();
|
|
451
|
+
const variable = readVariable(template, at);
|
|
452
|
+
nodes.push(variable.node);
|
|
453
|
+
at = variable.next;
|
|
454
|
+
} else {
|
|
455
|
+
text2 += template[at];
|
|
456
|
+
at += 1;
|
|
457
|
+
}
|
|
458
|
+
}
|
|
459
|
+
if (depth > 0)
|
|
460
|
+
throw new TitleTemplateError(`a "${GROUP_OPEN}" group is never closed`);
|
|
461
|
+
flush();
|
|
462
|
+
return { nodes, next: at };
|
|
463
|
+
}
|
|
464
|
+
function parseTitleTemplate(template) {
|
|
465
|
+
return readNodes(template, 0, 0).nodes;
|
|
466
|
+
}
|
|
467
|
+
function variablesOf(nodes) {
|
|
468
|
+
return nodes.flatMap((node) => {
|
|
469
|
+
if (node.kind === "variable")
|
|
470
|
+
return [node.name];
|
|
471
|
+
return node.kind === "group" ? variablesOf(node.nodes) : [];
|
|
472
|
+
});
|
|
473
|
+
}
|
|
474
|
+
function groupShows(nodes, values) {
|
|
475
|
+
return nodes.every((node) => node.kind !== "variable" || isPrintable(values[node.name]));
|
|
476
|
+
}
|
|
477
|
+
function printed(values, name) {
|
|
478
|
+
const value = values[name];
|
|
479
|
+
return isPrintable(value) ? value.trim() : "";
|
|
480
|
+
}
|
|
481
|
+
function shownValues(nodes, values) {
|
|
482
|
+
return Object.fromEntries(nodes.flatMap((node) => {
|
|
483
|
+
if (node.kind === "text")
|
|
484
|
+
return [];
|
|
485
|
+
if (node.kind === "variable") {
|
|
486
|
+
return printed(values, node.name) === "" ? [] : [[node.name, printed(values, node.name)]];
|
|
487
|
+
}
|
|
488
|
+
return groupShows(node.nodes, values) ? Object.entries(shownValues(node.nodes, values)) : [];
|
|
489
|
+
}));
|
|
490
|
+
}
|
|
491
|
+
function renderNodes(nodes, values) {
|
|
492
|
+
return nodes.map((node) => {
|
|
493
|
+
if (node.kind === "text")
|
|
494
|
+
return node.text;
|
|
495
|
+
if (node.kind === "variable")
|
|
496
|
+
return printed(values, node.name);
|
|
497
|
+
return groupShows(node.nodes, values) ? renderNodes(node.nodes, values) : "";
|
|
498
|
+
}).join("");
|
|
499
|
+
}
|
|
500
|
+
function renderTitle(template, values) {
|
|
501
|
+
return renderNodes(parseTitleTemplate(template), values).trim();
|
|
502
|
+
}
|
|
503
|
+
function escapeLiteral(text2) {
|
|
504
|
+
return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
505
|
+
}
|
|
506
|
+
function patternOf(nodes, last) {
|
|
507
|
+
return nodes.map((node) => {
|
|
508
|
+
if (node.kind === "text")
|
|
509
|
+
return escapeLiteral(node.text);
|
|
510
|
+
if (node.kind === "group")
|
|
511
|
+
return `(?:${patternOf(node.nodes, last)})?`;
|
|
512
|
+
const shape = node.name === last ? FREE_SHAPE : `${VARIABLE_SHAPES[node.name] ?? FREE_SHAPE}?`;
|
|
513
|
+
return `(?<${node.name}>${shape})`;
|
|
514
|
+
}).join("");
|
|
515
|
+
}
|
|
516
|
+
function parseTitle(template, title) {
|
|
517
|
+
const nodes = parseTitleTemplate(template);
|
|
518
|
+
const names = variablesOf(nodes);
|
|
519
|
+
const match = new RegExp(`^${patternOf(nodes, names.at(-1))}$`, "u").exec(title.trim());
|
|
520
|
+
if (match === null)
|
|
521
|
+
return null;
|
|
522
|
+
return Object.fromEntries(names.flatMap((name) => {
|
|
523
|
+
const value = match.groups?.[name];
|
|
524
|
+
return value === undefined ? [] : [[name, value]];
|
|
525
|
+
}));
|
|
526
|
+
}
|
|
527
|
+
function titleRoundTrips(template, values) {
|
|
528
|
+
const nodes = parseTitleTemplate(template);
|
|
529
|
+
const title = renderNodes(nodes, values).trim();
|
|
530
|
+
if (title === "")
|
|
531
|
+
return false;
|
|
532
|
+
const read = parseTitle(template, title) ?? {};
|
|
533
|
+
const shown = shownValues(nodes, values);
|
|
534
|
+
return variablesOf(nodes).every((name) => (read[name] ?? null) === (shown[name] ?? null));
|
|
535
|
+
}
|
|
536
|
+
var SAMPLE = {
|
|
537
|
+
type: "bug",
|
|
538
|
+
project: "api",
|
|
539
|
+
projectType: "cli",
|
|
540
|
+
module: "loop",
|
|
541
|
+
action: "start",
|
|
542
|
+
summary: "Does not find the branch: again"
|
|
543
|
+
};
|
|
544
|
+
function samplesOf(names) {
|
|
545
|
+
const optional = names.filter((name) => name !== SUMMARY);
|
|
546
|
+
const subsets = optional.reduce((found, name) => [...found, ...found.map((subset) => [...subset, name])], [[]]);
|
|
547
|
+
return subsets.map((subset) => Object.fromEntries([...subset, SUMMARY].map((name) => [name, SAMPLE[name]])));
|
|
548
|
+
}
|
|
549
|
+
function nodesProblem(template, nodes) {
|
|
550
|
+
const names = variablesOf(nodes);
|
|
551
|
+
const twice = names.find((name, index) => names.indexOf(name) !== index);
|
|
552
|
+
if (twice !== undefined)
|
|
553
|
+
return `\${${twice}} appears twice`;
|
|
554
|
+
if (names.at(-1) !== SUMMARY)
|
|
555
|
+
return `\${${SUMMARY}} must be the last variable`;
|
|
556
|
+
if (!nodes.some((node) => node.kind === "variable" && node.name === SUMMARY)) {
|
|
557
|
+
return `\${${SUMMARY}} must stand outside every ?( ) group`;
|
|
558
|
+
}
|
|
559
|
+
const failed = samplesOf(names).find((sample) => !titleRoundTrips(template, sample));
|
|
560
|
+
return failed === undefined ? null : `the title ${JSON.stringify(renderTitle(template, failed))} does not read back as the fields it was rendered from`;
|
|
561
|
+
}
|
|
562
|
+
function templateProblem(template) {
|
|
563
|
+
try {
|
|
564
|
+
return nodesProblem(template, parseTitleTemplate(template));
|
|
565
|
+
} catch (error) {
|
|
566
|
+
if (error instanceof TitleTemplateError)
|
|
567
|
+
return error.message;
|
|
568
|
+
throw error;
|
|
569
|
+
}
|
|
570
|
+
}
|
|
571
|
+
|
|
572
|
+
// src/config-schema-issues.ts
|
|
573
|
+
var SUMMARY_MAX_DEFAULT = 80;
|
|
574
|
+
var SUMMARY_MAX_FLOOR = 20;
|
|
575
|
+
var SUMMARY_MAX_CEILING = 120;
|
|
576
|
+
var TEMPLATE_EXPECTED = "a title template";
|
|
577
|
+
var PLACE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
|
|
578
|
+
var MODULE = new RegExp(`^${MODULE_SHAPE}$`);
|
|
579
|
+
var ACTION = new RegExp(`^${ACTION_SHAPE}$`);
|
|
580
|
+
function accepted(value) {
|
|
581
|
+
return { value, problems: [], extras: [] };
|
|
582
|
+
}
|
|
583
|
+
var titleTemplate = (raw, at) => {
|
|
584
|
+
if (typeof raw !== "string" || raw.trim() === "")
|
|
585
|
+
return refused(at, raw, TEMPLATE_EXPECTED);
|
|
586
|
+
const problem = templateProblem(raw);
|
|
587
|
+
return problem === null ? accepted(raw) : refused(at, raw, `${TEMPLATE_EXPECTED}: ${problem}`);
|
|
588
|
+
};
|
|
589
|
+
var summaryMax = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= SUMMARY_MAX_FLOOR && raw <= SUMMARY_MAX_CEILING ? accepted(raw) : refused(at, raw, `a whole number from ${SUMMARY_MAX_FLOOR} to ${SUMMARY_MAX_CEILING}`);
|
|
590
|
+
function nameOf(shape, reserved, expected) {
|
|
591
|
+
return (raw, at) => typeof raw === "string" && shape.test(raw) && !reserved.includes(raw) ? accepted(raw) : refused(at, raw, expected);
|
|
592
|
+
}
|
|
593
|
+
var place = nameOf(PLACE, [...BUILT_IN_ENVIRONMENTS, UNKNOWN_VALUE], `a place name in lower-case kebab-case, other than ${BUILT_IN_ENVIRONMENTS.join(", ")} and ${UNKNOWN_VALUE}`);
|
|
594
|
+
var moduleName = nameOf(MODULE, [UNKNOWN_VALUE], `a module name in lower-case letters, digits, ".", "_" and "-", other than ${UNKNOWN_VALUE}`);
|
|
595
|
+
var actionName = nameOf(ACTION, [UNKNOWN_VALUE], `an action in lower-case letters, digits, ".", "_", "-" and spaces, other than ${UNKNOWN_VALUE}`);
|
|
596
|
+
var ISSUES_DEFAULTS = Object.freeze({
|
|
597
|
+
issuesTitleBug: DEFAULT_BUG_TITLE,
|
|
598
|
+
issuesSummaryMax: SUMMARY_MAX_DEFAULT,
|
|
599
|
+
issuesEnvironments: Object.freeze([]),
|
|
600
|
+
issuesVocabularyModules: Object.freeze([]),
|
|
601
|
+
issuesVocabularyActions: Object.freeze([])
|
|
602
|
+
});
|
|
603
|
+
var ISSUES_SETTINGS = {
|
|
604
|
+
issuesTitleBug: { key: "issues.titles.bug", read: titleTemplate, cli: false },
|
|
605
|
+
issuesSummaryMax: { key: "issues.titles.summaryMax", read: summaryMax, cli: false },
|
|
606
|
+
issuesEnvironments: { key: "issues.environments", read: listOf(place, "place names"), cli: false },
|
|
607
|
+
issuesVocabularyModules: { key: "issues.vocabulary.modules", read: listOf(moduleName, "module names"), cli: false },
|
|
608
|
+
issuesVocabularyActions: { key: "issues.vocabulary.actions", read: listOf(actionName, "actions"), cli: false }
|
|
609
|
+
};
|
|
610
|
+
var ISSUES_SECTION = Object.freeze({
|
|
611
|
+
package: "issues",
|
|
612
|
+
settings: Object.freeze(ISSUES_SETTINGS),
|
|
613
|
+
defaults: ISSUES_DEFAULTS
|
|
614
|
+
});
|
|
615
|
+
function bugRulesOf(config) {
|
|
616
|
+
return {
|
|
617
|
+
template: config.issuesTitleBug,
|
|
618
|
+
summaryMax: config.issuesSummaryMax,
|
|
619
|
+
environments: [...BUILT_IN_ENVIRONMENTS, ...config.issuesEnvironments],
|
|
620
|
+
modules: config.issuesVocabularyModules,
|
|
621
|
+
actions: config.issuesVocabularyActions,
|
|
622
|
+
codes: listedCodes(config.errorsCodes)
|
|
623
|
+
};
|
|
624
|
+
}
|
|
625
|
+
|
|
626
|
+
// src/config-schema-loop-continue.ts
|
|
627
|
+
import { join } from "path";
|
|
628
|
+
var RETRIES_ON_CONTINUE_MIN = 1;
|
|
629
|
+
var RETRIES_ON_CONTINUE_MAX = 3;
|
|
630
|
+
var FORCE_WRAP_UP_MAX_NEW_FAILURES_MIN = 1;
|
|
631
|
+
var FORCE_WRAP_UP_MAX_NEW_FAILURES_MAX = 50;
|
|
632
|
+
var CONTINUE_CRITERIA_MODES = ["extend", "replace"];
|
|
633
|
+
function countOrFalse(min, max) {
|
|
634
|
+
const expected = `false or a whole number from ${String(min)} to ${String(max)}`;
|
|
635
|
+
return (raw, at) => raw === false || typeof raw === "number" && Number.isSafeInteger(raw) && raw >= min && raw <= max ? { value: raw, problems: [], extras: [] } : refused(at, raw, expected);
|
|
636
|
+
}
|
|
637
|
+
var retriesOnContinue = countOrFalse(RETRIES_ON_CONTINUE_MIN, RETRIES_ON_CONTINUE_MAX);
|
|
638
|
+
var forceWrapUpMaxNewFailures = countOrFalse(FORCE_WRAP_UP_MAX_NEW_FAILURES_MIN, FORCE_WRAP_UP_MAX_NEW_FAILURES_MAX);
|
|
639
|
+
var continueCriteria = text("a file path");
|
|
640
|
+
var continueCriteriaMode = oneOf(CONTINUE_CRITERIA_MODES);
|
|
641
|
+
var LOOP_CONTINUE_DEFAULTS = Object.freeze({
|
|
642
|
+
loopRetriesOnContinue: 1,
|
|
643
|
+
loopContinueCriteria: join(".rafa", "continue-criteria.md"),
|
|
644
|
+
loopContinueCriteriaMode: "extend",
|
|
645
|
+
loopForceWrapUpMaxNewFailures: false
|
|
646
|
+
});
|
|
647
|
+
var LOOP_CONTINUE_SETTINGS = {
|
|
648
|
+
loopRetriesOnContinue: { key: "loop.retriesOnContinue", read: retriesOnContinue, cli: false },
|
|
649
|
+
loopContinueCriteria: { key: "loop.continue.criteria", read: continueCriteria, cli: false },
|
|
650
|
+
loopContinueCriteriaMode: { key: "loop.continue.criteriaMode", read: continueCriteriaMode, cli: false },
|
|
651
|
+
loopForceWrapUpMaxNewFailures: {
|
|
652
|
+
key: "loop.forceWrapUp.maxNewFailures",
|
|
653
|
+
read: forceWrapUpMaxNewFailures,
|
|
654
|
+
cli: false
|
|
655
|
+
}
|
|
656
|
+
};
|
|
657
|
+
var LOOP_CONTINUE_SECTION = Object.freeze({
|
|
658
|
+
package: "loop-continue",
|
|
659
|
+
settings: Object.freeze(LOOP_CONTINUE_SETTINGS),
|
|
660
|
+
defaults: LOOP_CONTINUE_DEFAULTS
|
|
661
|
+
});
|
|
662
|
+
|
|
663
|
+
// src/config-schema-loop-retries.ts
|
|
664
|
+
var LOOP_RETRIES_MIN = 1;
|
|
665
|
+
var LOOP_RETRIES_MAX = 3;
|
|
666
|
+
function isLoopRetryCount(raw) {
|
|
667
|
+
return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= LOOP_RETRIES_MIN && raw <= LOOP_RETRIES_MAX;
|
|
668
|
+
}
|
|
669
|
+
var loopRetries = (raw, at) => raw === false || isLoopRetryCount(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or a whole number from ${String(LOOP_RETRIES_MIN)} to ${String(LOOP_RETRIES_MAX)}`);
|
|
670
|
+
var LOOP_RETRIES_DEFAULTS = Object.freeze({
|
|
671
|
+
loopRetries: false
|
|
672
|
+
});
|
|
673
|
+
var LOOP_RETRIES_SETTINGS = {
|
|
674
|
+
loopRetries: { key: "loop.retries", read: loopRetries, cli: false }
|
|
675
|
+
};
|
|
676
|
+
var LOOP_RETRIES_SECTION = Object.freeze({
|
|
677
|
+
package: "loop-retries",
|
|
678
|
+
settings: Object.freeze(LOOP_RETRIES_SETTINGS),
|
|
679
|
+
defaults: LOOP_RETRIES_DEFAULTS
|
|
680
|
+
});
|
|
681
|
+
|
|
682
|
+
// src/config-schema-release.ts
|
|
683
|
+
var PR_DEFAULTS = Object.freeze({
|
|
684
|
+
prProvider: null,
|
|
685
|
+
prMergeMethod: "squash",
|
|
686
|
+
prBase: null,
|
|
687
|
+
prResolveBudget: 2,
|
|
688
|
+
prVersionCollision: "report"
|
|
689
|
+
});
|
|
690
|
+
var RELEASE_DEFAULTS = Object.freeze({
|
|
691
|
+
releaseEnabled: RELEASE_AUTO,
|
|
692
|
+
releaseVersionFile: "package.json",
|
|
693
|
+
releaseChangelog: "CHANGELOG.md",
|
|
694
|
+
releaseHeading: "## {version} \u2014 {date}, {title}",
|
|
695
|
+
releaseFragments: ".changes",
|
|
696
|
+
releaseStrategy: "semver-by-level",
|
|
697
|
+
releaseSettle: "push",
|
|
698
|
+
releaseTag: "manual",
|
|
699
|
+
releasePublishCommand: "npm publish",
|
|
700
|
+
releasePublish: "manual",
|
|
701
|
+
releaseMoveLock: false
|
|
702
|
+
});
|
|
703
|
+
var DANGEROUS_RELEASE_DEFAULTS = Object.freeze({
|
|
704
|
+
dangerousAcceptVersionCollision: false
|
|
705
|
+
});
|
|
706
|
+
var mergeMethod = oneOf(MERGE_METHODS);
|
|
707
|
+
var PR_SETTINGS = {
|
|
708
|
+
prProvider: { key: "pr.provider", read: oneOf(PR_PROVIDERS), cli: false },
|
|
709
|
+
prMergeMethod: { key: "pr.mergeMethod", read: mergeMethod, cli: false },
|
|
710
|
+
prBase: { key: "pr.base", read: text("a branch name"), cli: false },
|
|
711
|
+
prResolveBudget: { key: "pr.resolveBudget", read: usdAmount, cli: false },
|
|
712
|
+
prVersionCollision: {
|
|
713
|
+
key: "pr.versionCollision",
|
|
714
|
+
read: versionCollisionMode,
|
|
715
|
+
cli: false
|
|
716
|
+
}
|
|
717
|
+
};
|
|
718
|
+
var RELEASE_SETTINGS = {
|
|
719
|
+
releaseEnabled: { key: "release.enabled", read: releaseEnabled, cli: false },
|
|
720
|
+
releaseVersionFile: {
|
|
721
|
+
key: "release.versionFile",
|
|
722
|
+
read: releaseFile,
|
|
723
|
+
cli: false
|
|
724
|
+
},
|
|
725
|
+
releaseChangelog: { key: "release.changelog", read: releaseFile, cli: false },
|
|
726
|
+
releaseHeading: {
|
|
727
|
+
key: "release.heading",
|
|
728
|
+
read: text("a changelog heading template"),
|
|
729
|
+
cli: false
|
|
730
|
+
},
|
|
731
|
+
releaseFragments: {
|
|
732
|
+
key: "release.fragments",
|
|
733
|
+
read: fragmentsDirectory,
|
|
734
|
+
cli: false
|
|
735
|
+
},
|
|
736
|
+
releaseStrategy: { key: "release.strategy", read: releaseStrategy, cli: false },
|
|
737
|
+
releaseSettle: { key: "release.settle", read: releaseSettleMode, cli: false },
|
|
738
|
+
releaseTag: { key: "release.tag", read: releaseTagMode, cli: false },
|
|
739
|
+
releasePublishCommand: {
|
|
740
|
+
key: "release.publishCommand",
|
|
741
|
+
read: text("a publish command"),
|
|
742
|
+
cli: false
|
|
743
|
+
},
|
|
744
|
+
releasePublish: { key: "release.publish", read: releasePublishMode, cli: false },
|
|
745
|
+
releaseMoveLock: { key: "release.moveLock", read: flag, cli: false }
|
|
746
|
+
};
|
|
747
|
+
var DANGEROUS_RELEASE_SETTINGS = {
|
|
748
|
+
dangerousAcceptVersionCollision: {
|
|
749
|
+
key: "dangerous.acceptVersionCollision",
|
|
750
|
+
read: flag,
|
|
751
|
+
cli: false
|
|
752
|
+
}
|
|
753
|
+
};
|
|
754
|
+
var RELEASE_SECTION = Object.freeze({
|
|
755
|
+
package: "release",
|
|
756
|
+
settings: Object.freeze({ ...PR_SETTINGS, ...RELEASE_SETTINGS, ...DANGEROUS_RELEASE_SETTINGS }),
|
|
757
|
+
defaults: Object.freeze({ ...PR_DEFAULTS, ...RELEASE_DEFAULTS, ...DANGEROUS_RELEASE_DEFAULTS })
|
|
758
|
+
});
|
|
759
|
+
|
|
760
|
+
// src/config-schema-tests.ts
|
|
761
|
+
import { isAbsolute } from "path";
|
|
762
|
+
var GLOB_PATTERN = "a glob pattern relative to the repository root";
|
|
763
|
+
var repoGlob = (raw, at) => typeof raw === "string" && isAbsolute(raw) ? refused(at, raw, GLOB_PATTERN) : text(GLOB_PATTERN)(raw, at);
|
|
764
|
+
var globList = listOf(repoGlob, "glob patterns");
|
|
765
|
+
var TESTS_DEFAULTS = Object.freeze({
|
|
766
|
+
testsFullSuiteTriggers: Object.freeze([]),
|
|
767
|
+
testsIntegration: Object.freeze([]),
|
|
768
|
+
testsContract: Object.freeze([]),
|
|
769
|
+
testsAlwaysRun: Object.freeze(["src/**/*.sweep.test.ts"]),
|
|
770
|
+
testsRetakeRedAlone: true
|
|
771
|
+
});
|
|
772
|
+
var TESTS_SETTINGS = {
|
|
773
|
+
testsFullSuiteTriggers: {
|
|
774
|
+
key: "tests.fullSuiteTriggers",
|
|
775
|
+
read: globList,
|
|
776
|
+
cli: false
|
|
777
|
+
},
|
|
778
|
+
testsIntegration: { key: "tests.integration", read: globList, cli: false },
|
|
779
|
+
testsContract: { key: "tests.contract", read: globList, cli: false },
|
|
780
|
+
testsAlwaysRun: { key: "tests.alwaysRun", read: globList, cli: false },
|
|
781
|
+
testsRetakeRedAlone: { key: "tests.retakeRedAlone", read: flag, cli: false }
|
|
782
|
+
};
|
|
783
|
+
var TESTS_SECTION = Object.freeze({
|
|
784
|
+
package: "tests",
|
|
785
|
+
settings: Object.freeze(TESTS_SETTINGS),
|
|
786
|
+
defaults: TESTS_DEFAULTS
|
|
787
|
+
});
|
|
788
|
+
|
|
789
|
+
// src/config-schema-triage.ts
|
|
790
|
+
var SIMILARITY_THRESHOLD_MAX = 1;
|
|
791
|
+
var SIMILARITY_WEIGHT_MIN = 0;
|
|
792
|
+
var SIMILARITY_WEIGHT_MAX = 1;
|
|
793
|
+
var SIMILARITY_CANDIDATES_MIN = 1;
|
|
794
|
+
var SIMILARITY_CANDIDATES_MAX = 10;
|
|
795
|
+
function isThreshold(raw) {
|
|
796
|
+
return typeof raw === "number" && Number.isFinite(raw) && raw > 0 && raw <= SIMILARITY_THRESHOLD_MAX;
|
|
797
|
+
}
|
|
798
|
+
function isCandidateCount(raw) {
|
|
799
|
+
return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= SIMILARITY_CANDIDATES_MIN && raw <= SIMILARITY_CANDIDATES_MAX;
|
|
800
|
+
}
|
|
801
|
+
function isWeight(raw) {
|
|
802
|
+
return typeof raw === "number" && Number.isFinite(raw) && raw >= SIMILARITY_WEIGHT_MIN && raw <= SIMILARITY_WEIGHT_MAX;
|
|
803
|
+
}
|
|
804
|
+
var similarityThreshold = (raw, at) => raw === false || isThreshold(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or a number above 0 and at most ${String(SIMILARITY_THRESHOLD_MAX)}`);
|
|
805
|
+
var similarityCandidates = (raw, at) => isCandidateCount(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `a whole number from ${String(SIMILARITY_CANDIDATES_MIN)} to ${String(SIMILARITY_CANDIDATES_MAX)}`);
|
|
806
|
+
var similarityWeight = (raw, at) => isWeight(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `a number from ${String(SIMILARITY_WEIGHT_MIN)} to ${String(SIMILARITY_WEIGHT_MAX)}`);
|
|
807
|
+
var TRIAGE_DEFAULTS = Object.freeze({
|
|
808
|
+
triageSimilarityThreshold: 0.3,
|
|
809
|
+
triageSimilarityCandidates: 3,
|
|
810
|
+
triageSimilarityWeightsCauseLeaf: 0.15,
|
|
811
|
+
triageSimilarityWeightsCauseFamily: 0.05,
|
|
812
|
+
triageSimilarityWeightsBoundary: 0.1
|
|
813
|
+
});
|
|
814
|
+
var TRIAGE_SETTINGS = {
|
|
815
|
+
triageSimilarityThreshold: {
|
|
816
|
+
key: "triage.similarity.threshold",
|
|
817
|
+
read: similarityThreshold,
|
|
818
|
+
cli: false
|
|
819
|
+
},
|
|
820
|
+
triageSimilarityCandidates: {
|
|
821
|
+
key: "triage.similarity.candidates",
|
|
822
|
+
read: similarityCandidates,
|
|
823
|
+
cli: false
|
|
824
|
+
},
|
|
825
|
+
triageSimilarityWeightsCauseLeaf: {
|
|
826
|
+
key: "triage.similarity.weights.causeLeaf",
|
|
827
|
+
read: similarityWeight,
|
|
828
|
+
cli: false
|
|
829
|
+
},
|
|
830
|
+
triageSimilarityWeightsCauseFamily: {
|
|
831
|
+
key: "triage.similarity.weights.causeFamily",
|
|
832
|
+
read: similarityWeight,
|
|
833
|
+
cli: false
|
|
834
|
+
},
|
|
835
|
+
triageSimilarityWeightsBoundary: {
|
|
836
|
+
key: "triage.similarity.weights.boundary",
|
|
837
|
+
read: similarityWeight,
|
|
838
|
+
cli: false
|
|
839
|
+
}
|
|
840
|
+
};
|
|
841
|
+
var TRIAGE_SECTION = Object.freeze({
|
|
842
|
+
package: "triage",
|
|
843
|
+
settings: Object.freeze(TRIAGE_SETTINGS),
|
|
844
|
+
defaults: TRIAGE_DEFAULTS
|
|
845
|
+
});
|
|
846
|
+
|
|
847
|
+
// src/config-schema-wrap-up.ts
|
|
848
|
+
var WRAP_UP_RETRIES_MIN = 1;
|
|
849
|
+
var WRAP_UP_RETRIES_MAX = 3;
|
|
850
|
+
function isRetryCount(raw) {
|
|
851
|
+
return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= WRAP_UP_RETRIES_MIN && raw <= WRAP_UP_RETRIES_MAX;
|
|
852
|
+
}
|
|
853
|
+
var wrapUpRetries = (raw, at) => raw === false || isRetryCount(raw) ? { value: raw, problems: [], extras: [] } : refused(at, raw, `false or a whole number from ${String(WRAP_UP_RETRIES_MIN)} to ${String(WRAP_UP_RETRIES_MAX)}`);
|
|
854
|
+
var WRAP_UP_DEFAULTS = Object.freeze({
|
|
855
|
+
loopWrapUpRetries: 1
|
|
856
|
+
});
|
|
857
|
+
var WRAP_UP_SETTINGS = {
|
|
858
|
+
loopWrapUpRetries: { key: "loop.wrapUp.retries", read: wrapUpRetries, cli: false }
|
|
859
|
+
};
|
|
860
|
+
var WRAP_UP_SECTION = Object.freeze({
|
|
861
|
+
package: "wrap-up",
|
|
862
|
+
settings: Object.freeze(WRAP_UP_SETTINGS),
|
|
863
|
+
defaults: WRAP_UP_DEFAULTS
|
|
864
|
+
});
|
|
865
|
+
|
|
866
|
+
// src/config-registry.ts
|
|
867
|
+
var CONFIG_SECTIONS = Object.freeze([
|
|
868
|
+
CORE_SECTION,
|
|
869
|
+
HUB_SECTION,
|
|
870
|
+
LOOP_RETRIES_SECTION,
|
|
871
|
+
LOOP_CONTINUE_SECTION,
|
|
872
|
+
WRAP_UP_SECTION,
|
|
873
|
+
RELEASE_SECTION,
|
|
874
|
+
BOARD_PROJECT_SECTION,
|
|
875
|
+
TRIAGE_SECTION,
|
|
876
|
+
ERRORS_SECTION,
|
|
877
|
+
BUGS_SECTION,
|
|
878
|
+
LOGGER_SECTION,
|
|
879
|
+
ISSUES_SECTION,
|
|
880
|
+
TESTS_SECTION,
|
|
881
|
+
CHECKS_SECTION,
|
|
882
|
+
FEATURES_SECTION
|
|
883
|
+
]);
|
|
884
|
+
function handConfigToLogger(config) {
|
|
885
|
+
setActiveLoggerSettings(loggerSettingsOf(config));
|
|
886
|
+
}
|
|
887
|
+
var CORE_HEAD = ["version", "store", "effortBusyTimeoutMs", "effortSync"];
|
|
888
|
+
var CORE_PLAN_TO_LOOP = [
|
|
889
|
+
"inject",
|
|
890
|
+
"planDir",
|
|
891
|
+
"specsDir",
|
|
892
|
+
"trackerDefault",
|
|
893
|
+
"trackerFallback",
|
|
894
|
+
"learningAdapter",
|
|
895
|
+
"learningBlessMinConfidence",
|
|
896
|
+
"learningPromoteAfter",
|
|
897
|
+
"learningPromoteMinConfidence",
|
|
898
|
+
"outputMode",
|
|
899
|
+
"prerequisitesRequired",
|
|
900
|
+
"prerequisitesOptional",
|
|
901
|
+
"trackingSpecs",
|
|
902
|
+
"trackingPlans",
|
|
903
|
+
"trackingAll",
|
|
904
|
+
"modules",
|
|
905
|
+
"allowList",
|
|
906
|
+
"settingSources",
|
|
907
|
+
"loopWorktreeDir"
|
|
908
|
+
];
|
|
909
|
+
var CORE_BOARD = [
|
|
910
|
+
"boardTrustedAuthors",
|
|
911
|
+
"boardRelationships",
|
|
912
|
+
"boardProjectTemplate",
|
|
913
|
+
"boardProjectNumber"
|
|
914
|
+
];
|
|
915
|
+
var CORE_CLAIMS = ["roadmapIssue", "claimsStaleAfter", "claimsAhead"];
|
|
916
|
+
var CORE_CLEANUP = [
|
|
917
|
+
"cleanupStaleDays",
|
|
918
|
+
"cleanupWorktreeIdleDays",
|
|
919
|
+
"cleanupKeep",
|
|
920
|
+
"dangerousAcceptStaleRefs"
|
|
921
|
+
];
|
|
922
|
+
var CORE_TAIL = [
|
|
923
|
+
"dangerousSelfUpdateDuringLoop",
|
|
924
|
+
"statusNotice",
|
|
925
|
+
"tiersRafa",
|
|
926
|
+
"tiersSkills",
|
|
927
|
+
"tiersAgents",
|
|
928
|
+
"routing",
|
|
929
|
+
"taskSkills",
|
|
930
|
+
"taskLessons",
|
|
931
|
+
"mergeDuplicates",
|
|
932
|
+
"namingBranch",
|
|
933
|
+
"templates"
|
|
934
|
+
];
|
|
935
|
+
function run(record, names) {
|
|
936
|
+
return Object.fromEntries(names.map((name) => [name, record[name]]));
|
|
937
|
+
}
|
|
938
|
+
var CORE_SPECS = CORE_SECTION.settings;
|
|
939
|
+
var CORE_VALUES = CORE_SECTION.defaults;
|
|
940
|
+
var CONFIG_DEFAULTS = Object.freeze({
|
|
941
|
+
...run(CORE_VALUES, CORE_HEAD),
|
|
942
|
+
...HUB_DEFAULTS,
|
|
943
|
+
...run(CORE_VALUES, CORE_PLAN_TO_LOOP),
|
|
944
|
+
...LOOP_RETRIES_DEFAULTS,
|
|
945
|
+
...LOOP_CONTINUE_DEFAULTS,
|
|
946
|
+
...WRAP_UP_DEFAULTS,
|
|
947
|
+
...PR_DEFAULTS,
|
|
948
|
+
...run(CORE_VALUES, CORE_BOARD),
|
|
949
|
+
...BOARD_PROJECT_LIMIT_DEFAULTS,
|
|
950
|
+
...run(CORE_VALUES, CORE_CLAIMS),
|
|
951
|
+
...TRIAGE_DEFAULTS,
|
|
952
|
+
...RELEASE_DEFAULTS,
|
|
953
|
+
...ERRORS_DEFAULTS,
|
|
954
|
+
...BUGS_DEFAULTS,
|
|
955
|
+
...LOGGER_DEFAULTS,
|
|
956
|
+
...ISSUES_DEFAULTS,
|
|
957
|
+
...run(CORE_VALUES, CORE_CLEANUP),
|
|
958
|
+
...DANGEROUS_RELEASE_DEFAULTS,
|
|
959
|
+
...run(CORE_VALUES, CORE_TAIL),
|
|
960
|
+
...TESTS_DEFAULTS,
|
|
961
|
+
...CHECKS_DEFAULTS,
|
|
962
|
+
...FEATURES_DEFAULTS
|
|
963
|
+
});
|
|
964
|
+
var SETTINGS = Object.freeze({
|
|
965
|
+
...run(CORE_SPECS, CORE_HEAD),
|
|
966
|
+
...HUB_SETTINGS,
|
|
967
|
+
...run(CORE_SPECS, CORE_PLAN_TO_LOOP),
|
|
968
|
+
...LOOP_RETRIES_SETTINGS,
|
|
969
|
+
...LOOP_CONTINUE_SETTINGS,
|
|
970
|
+
...WRAP_UP_SETTINGS,
|
|
971
|
+
...PR_SETTINGS,
|
|
972
|
+
...run(CORE_SPECS, CORE_BOARD),
|
|
973
|
+
...BOARD_PROJECT_LIMIT_SETTINGS,
|
|
974
|
+
...run(CORE_SPECS, CORE_CLAIMS),
|
|
975
|
+
...TRIAGE_SETTINGS,
|
|
976
|
+
...RELEASE_SETTINGS,
|
|
977
|
+
...ERRORS_SETTINGS,
|
|
978
|
+
...BUGS_SETTINGS,
|
|
979
|
+
...LOGGER_SETTINGS,
|
|
980
|
+
...ISSUES_SETTINGS,
|
|
981
|
+
...run(CORE_SPECS, CORE_CLEANUP),
|
|
982
|
+
...DANGEROUS_RELEASE_SETTINGS,
|
|
983
|
+
...run(CORE_SPECS, CORE_TAIL),
|
|
984
|
+
...TESTS_SETTINGS,
|
|
985
|
+
...CHECKS_SETTINGS,
|
|
986
|
+
...FEATURES_SETTINGS
|
|
987
|
+
});
|
|
988
|
+
var SETTING_NAMES = Object.freeze(Object.keys(SETTINGS));
|
|
989
|
+
function inSettingOrder(sections, names) {
|
|
990
|
+
const cuts = names.reduce((runs, name) => {
|
|
991
|
+
const section = sections.find((candidate) => Object.hasOwn(candidate.settings, name));
|
|
992
|
+
if (section === undefined)
|
|
993
|
+
throw new Error(`rafa config registry: no section defines setting ${name}`);
|
|
994
|
+
const last = runs.at(-1);
|
|
995
|
+
return last?.section === section ? [...runs.slice(0, -1), { section, names: [...last.names, name] }] : [...runs, { section, names: [name] }];
|
|
996
|
+
}, []);
|
|
997
|
+
return cuts.map(({ section, names: run2 }, index) => ({
|
|
998
|
+
package: section.package,
|
|
999
|
+
settings: Object.fromEntries(run2.map((name) => [name, section.settings[name]])),
|
|
1000
|
+
defaults: Object.fromEntries(run2.map((name) => [name, section.defaults[name]])),
|
|
1001
|
+
checks: cuts.findIndex((cut) => cut.section === section) === index ? section.checks ?? [] : []
|
|
1002
|
+
}));
|
|
1003
|
+
}
|
|
1004
|
+
function holdsCoreSections() {
|
|
1005
|
+
const active = activeSettings();
|
|
1006
|
+
return SETTING_NAMES.every((name) => active[name] === SETTINGS[name]);
|
|
1007
|
+
}
|
|
1008
|
+
function registerCoreConfigSections() {
|
|
1009
|
+
if (holdsCoreSections())
|
|
1010
|
+
return;
|
|
1011
|
+
registerConfigSections(inSettingOrder(CONFIG_SECTIONS, SETTING_NAMES));
|
|
1012
|
+
setConfigLoadHook(handConfigToLogger);
|
|
1013
|
+
setConfigTemplateHook(templateEntry);
|
|
1014
|
+
}
|
|
1015
|
+
var SETTING_BY_KEY = new Map(SETTING_NAMES.map((setting) => [
|
|
1016
|
+
SETTINGS[setting].key,
|
|
1017
|
+
setting
|
|
1018
|
+
]));
|
|
1019
|
+
function sectionsOf(key) {
|
|
1020
|
+
const parts = key.split(".");
|
|
1021
|
+
return parts.slice(1).map((_, index) => parts.slice(0, index + 1).join("."));
|
|
1022
|
+
}
|
|
1023
|
+
var SECTIONS = new Set([...SETTING_BY_KEY.keys()].flatMap(sectionsOf));
|
|
1024
|
+
var KNOWN_UNDER = (() => {
|
|
1025
|
+
const known = new Map;
|
|
1026
|
+
const add = (parent, name) => {
|
|
1027
|
+
const names = known.get(parent) ?? [];
|
|
1028
|
+
if (!names.includes(name))
|
|
1029
|
+
known.set(parent, [...names, name]);
|
|
1030
|
+
};
|
|
1031
|
+
for (const setting of SETTING_NAMES) {
|
|
1032
|
+
const { key, itemKeys } = SETTINGS[setting];
|
|
1033
|
+
const parts = key.split(".");
|
|
1034
|
+
parts.forEach((part, index) => add(parts.slice(0, index).join("."), part));
|
|
1035
|
+
for (const name of itemKeys ?? [])
|
|
1036
|
+
add(`${key}[]`, name);
|
|
1037
|
+
}
|
|
1038
|
+
return known;
|
|
1039
|
+
})();
|
|
1040
|
+
|
|
1041
|
+
export { hubContextOf, FEATURES_SETTINGS, ERRORS_DEFAULTS, CONFIG_TEMPLATES, suggestedEnvironment, UNKNOWN_VALUE, MODULE_SHAPE, ACTION_SHAPE, renderTitle, titleRoundTrips, ISSUES_DEFAULTS, bugRulesOf, isLoopRetryCount, RELEASE_DEFAULTS, CONFIG_DEFAULTS, SETTINGS, SETTING_NAMES, registerCoreConfigSections };
|