waymark-cli 0.1.0__py3-none-any.whl
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.
- waymark/__init__.py +3 -0
- waymark/__main__.py +8 -0
- waymark/adapters/__init__.py +102 -0
- waymark/adapters/claude_code.py +238 -0
- waymark/assets/__init__.py +43 -0
- waymark/assets/agents/wm-implementer.md +45 -0
- waymark/assets/agents/wm-reviewer.md +43 -0
- waymark/assets/skills/wm-apply/SKILL.md +58 -0
- waymark/assets/skills/wm-archive/SKILL.md +32 -0
- waymark/assets/skills/wm-explore/SKILL.md +34 -0
- waymark/assets/skills/wm-kickoff/SKILL.md +34 -0
- waymark/assets/skills/wm-onboard/SKILL.md +27 -0
- waymark/assets/skills/wm-pr/SKILL.md +24 -0
- waymark/assets/skills/wm-propose/SKILL.md +32 -0
- waymark/assets/skills/wm-update/SKILL.md +31 -0
- waymark/cli.py +537 -0
- waymark/hooks/__init__.py +6 -0
- waymark/hooks/commands.py +190 -0
- waymark/hooks/decide.py +314 -0
- waymark/hooks/events.py +79 -0
- waymark/py.typed +0 -0
- waymark/record/__init__.py +5 -0
- waymark/record/atlas.py +156 -0
- waymark/record/changes.py +202 -0
- waymark/record/charter.py +75 -0
- waymark/record/commits.py +78 -0
- waymark/record/config.py +215 -0
- waymark/record/deltas.py +318 -0
- waymark/record/design.py +80 -0
- waymark/record/edits.py +95 -0
- waymark/record/evidence.py +58 -0
- waymark/record/explorations.py +66 -0
- waymark/record/files.py +75 -0
- waymark/record/fingerprint.py +73 -0
- waymark/record/git.py +167 -0
- waymark/record/githooks.py +106 -0
- waymark/record/links.py +104 -0
- waymark/record/milestones.py +84 -0
- waymark/record/moves.py +60 -0
- waymark/record/names.py +39 -0
- waymark/record/outline.py +144 -0
- waymark/record/pointer.py +56 -0
- waymark/record/problems.py +20 -0
- waymark/record/project.py +118 -0
- waymark/record/proposal.py +171 -0
- waymark/record/record.py +340 -0
- waymark/record/registry.py +158 -0
- waymark/record/specs.py +227 -0
- waymark/record/state.py +472 -0
- waymark/record/store.py +88 -0
- waymark/record/tasks.py +415 -0
- waymark/record/templates/charter.md +45 -0
- waymark/record/templates/ci-workflow.yml +29 -0
- waymark/record/templates/config-atlas.toml +8 -0
- waymark/record/templates/config.toml +19 -0
- waymark/record/templates/delta.md +29 -0
- waymark/record/templates/design.md +20 -0
- waymark/record/templates/exploration.md +22 -0
- waymark/record/templates/goal.md +13 -0
- waymark/record/templates/hook-commit-msg +8 -0
- waymark/record/templates/hook-pre-commit +8 -0
- waymark/record/templates/proposal.md +18 -0
- waymark/record/templates/roadmap.md +4 -0
- waymark/record/templates/tasks.md +10 -0
- waymark/record/templates.py +30 -0
- waymark/record/terms.py +51 -0
- waymark/record/text.py +197 -0
- waymark/services/__init__.py +1 -0
- waymark/services/atlas.py +162 -0
- waymark/services/check.py +129 -0
- waymark/services/ci.py +44 -0
- waymark/services/common.py +154 -0
- waymark/services/context.py +296 -0
- waymark/services/doctor.py +367 -0
- waymark/services/githooks.py +132 -0
- waymark/services/instructions.py +304 -0
- waymark/services/integration.py +170 -0
- waymark/services/lifecycle.py +454 -0
- waymark/services/migrations.py +90 -0
- waymark/services/pr.py +177 -0
- waymark/services/references.py +27 -0
- waymark/services/setup.py +127 -0
- waymark/views/__init__.py +5 -0
- waymark/views/payloads.py +568 -0
- waymark/views/render.py +506 -0
- waymark/views/schemas.py +413 -0
- waymark/views/style.py +102 -0
- waymark_cli-0.1.0.dist-info/METADATA +313 -0
- waymark_cli-0.1.0.dist-info/RECORD +92 -0
- waymark_cli-0.1.0.dist-info/WHEEL +4 -0
- waymark_cli-0.1.0.dist-info/entry_points.txt +2 -0
- waymark_cli-0.1.0.dist-info/licenses/LICENSE +21 -0
|
@@ -0,0 +1,367 @@
|
|
|
1
|
+
"""Checking the setup on this machine. Nothing here changes anything.
|
|
2
|
+
|
|
3
|
+
``doctor`` checks wm itself, git, the project and its agent tool files.
|
|
4
|
+
``atlas_doctor`` checks an atlas's registry entries, code repos, branches and
|
|
5
|
+
pins.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
import shutil
|
|
9
|
+
from dataclasses import dataclass
|
|
10
|
+
from enum import StrEnum
|
|
11
|
+
from pathlib import Path
|
|
12
|
+
|
|
13
|
+
from waymark import __version__
|
|
14
|
+
from waymark.record import git
|
|
15
|
+
from waymark.record.atlas import Found, locate_atlas, locate_repo, read_pointer
|
|
16
|
+
from waymark.record.config import CONFIG_FILE, RECORD_DIR, RECORD_FORMAT
|
|
17
|
+
from waymark.record.files import RecordFiles
|
|
18
|
+
from waymark.record.githooks import HOOKS_DIR, HooksState, hooks_status
|
|
19
|
+
from waymark.record.pointer import POINTER_FILE
|
|
20
|
+
from waymark.record.project import Project, ProjectNotFoundError, find_project
|
|
21
|
+
from waymark.record.record import Record, load_record
|
|
22
|
+
from waymark.record.registry import Registry, load_registry
|
|
23
|
+
from waymark.services import integration
|
|
24
|
+
from waymark.services.common import Refusal, install_hint
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
class Status(StrEnum):
|
|
28
|
+
"""How one check came out. Only errors make the doctor fail."""
|
|
29
|
+
|
|
30
|
+
OK = "ok"
|
|
31
|
+
WARNING = "warning"
|
|
32
|
+
ERROR = "error"
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
@dataclass(frozen=True)
|
|
36
|
+
class Check:
|
|
37
|
+
"""One check: what it looked at, how it came out, and what to do.
|
|
38
|
+
|
|
39
|
+
``folder`` is the place on this machine the check is about, if any.
|
|
40
|
+
"""
|
|
41
|
+
|
|
42
|
+
name: str
|
|
43
|
+
status: Status
|
|
44
|
+
message: str
|
|
45
|
+
folder: Path | None = None
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
@dataclass(frozen=True)
|
|
49
|
+
class Report:
|
|
50
|
+
"""What a doctor found."""
|
|
51
|
+
|
|
52
|
+
scope: str
|
|
53
|
+
checks: tuple[Check, ...]
|
|
54
|
+
|
|
55
|
+
@property
|
|
56
|
+
def failed(self) -> bool:
|
|
57
|
+
return any(check.status is Status.ERROR for check in self.checks)
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def _wm_on_path() -> Check:
|
|
61
|
+
found = shutil.which("wm")
|
|
62
|
+
if found is None:
|
|
63
|
+
return Check(
|
|
64
|
+
"wm on PATH",
|
|
65
|
+
Status.ERROR,
|
|
66
|
+
"wm is not on PATH, so agent tool hooks and git hooks can't run it. Install it as "
|
|
67
|
+
f"a tool: {install_hint(__version__)}",
|
|
68
|
+
)
|
|
69
|
+
return Check("wm on PATH", Status.OK, f"wm {__version__} is installed.", Path(found))
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
def _git() -> Check:
|
|
73
|
+
line = git.version()
|
|
74
|
+
if line is None:
|
|
75
|
+
return Check("git", Status.ERROR, "git can't be run. Install it and put it on PATH.")
|
|
76
|
+
return Check("git", Status.OK, line)
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
def _project_check(project: Project) -> Check:
|
|
80
|
+
if project.code_repo is not None:
|
|
81
|
+
return Check(
|
|
82
|
+
"project",
|
|
83
|
+
Status.OK,
|
|
84
|
+
"Found the atlas from the code repo this command ran in.",
|
|
85
|
+
project.root,
|
|
86
|
+
)
|
|
87
|
+
return Check("project", Status.OK, "Found the record.", project.root)
|
|
88
|
+
|
|
89
|
+
|
|
90
|
+
def _hooks_check(root: Path, *, optional: bool) -> Check:
|
|
91
|
+
"""Whether this clone runs the committed git hooks. In a code repo they are optional."""
|
|
92
|
+
name = "git hooks" if not optional else "code repo git hooks"
|
|
93
|
+
status = hooks_status(root)
|
|
94
|
+
if status.state is HooksState.SET:
|
|
95
|
+
return Check(name, Status.OK, f"Git runs the hooks in {HOOKS_DIR}/.", root)
|
|
96
|
+
if status.state is HooksState.MANAGED:
|
|
97
|
+
return Check(
|
|
98
|
+
name,
|
|
99
|
+
Status.OK,
|
|
100
|
+
f"wm left the hooks to another setup, because {status.manager}. Make sure it runs "
|
|
101
|
+
'"wm run-hook commit-msg" and "wm run-hook pre-commit".',
|
|
102
|
+
root,
|
|
103
|
+
)
|
|
104
|
+
if status.state is HooksState.NOT_SET:
|
|
105
|
+
return Check(
|
|
106
|
+
name,
|
|
107
|
+
Status.WARNING,
|
|
108
|
+
f'This clone doesn\'t run the hooks in {HOOKS_DIR}/. Run "wm git-hooks" to point '
|
|
109
|
+
"git at them.",
|
|
110
|
+
root,
|
|
111
|
+
)
|
|
112
|
+
if optional:
|
|
113
|
+
return Check(name, Status.OK, 'No Waymark hooks; "wm git-hooks" adds them.', root)
|
|
114
|
+
return Check(
|
|
115
|
+
name,
|
|
116
|
+
Status.WARNING,
|
|
117
|
+
f'The project has no hooks in {HOOKS_DIR}/. Run "wm git-hooks" to add them.',
|
|
118
|
+
root,
|
|
119
|
+
)
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
def _pin_checks(record: Record) -> list[Check]:
|
|
123
|
+
config = record.config
|
|
124
|
+
if config is None:
|
|
125
|
+
problems = [p.message for p in record.problems if p.path == CONFIG_FILE]
|
|
126
|
+
detail = problems[0] if problems else "It could not be read."
|
|
127
|
+
return [Check("settings", Status.ERROR, f"{RECORD_DIR}/{CONFIG_FILE}: {detail}")]
|
|
128
|
+
checks: list[Check] = []
|
|
129
|
+
if config.wm_version != __version__:
|
|
130
|
+
checks.append(
|
|
131
|
+
Check(
|
|
132
|
+
"version pin",
|
|
133
|
+
Status.ERROR,
|
|
134
|
+
f"The project is pinned to wm {config.wm_version}, and this is wm {__version__}. "
|
|
135
|
+
f"Reading works; writing is refused. Install the pinned version: "
|
|
136
|
+
f"{install_hint(config.wm_version)}",
|
|
137
|
+
)
|
|
138
|
+
)
|
|
139
|
+
return checks
|
|
140
|
+
checks.append(Check("version pin", Status.OK, f"Pinned to wm {config.wm_version}."))
|
|
141
|
+
if config.record_format != RECORD_FORMAT:
|
|
142
|
+
checks.append(
|
|
143
|
+
Check(
|
|
144
|
+
"record format",
|
|
145
|
+
Status.WARNING,
|
|
146
|
+
f"The record is in format {config.record_format}; this wm writes format "
|
|
147
|
+
f'{RECORD_FORMAT}. Run "wm update" to migrate it.',
|
|
148
|
+
)
|
|
149
|
+
)
|
|
150
|
+
return checks
|
|
151
|
+
checks.append(Check("record format", Status.OK, f"Format {config.record_format}."))
|
|
152
|
+
checks.append(_tool_files(record))
|
|
153
|
+
return checks
|
|
154
|
+
|
|
155
|
+
|
|
156
|
+
def _tool_files(record: Record) -> Check:
|
|
157
|
+
assert record.config is not None
|
|
158
|
+
files = RecordFiles(record.project.root)
|
|
159
|
+
try:
|
|
160
|
+
wanted = integration.integration_files(files, record.config.agent_tools)
|
|
161
|
+
except Refusal as refusal:
|
|
162
|
+
return Check("agent tool files", Status.ERROR, str(refusal))
|
|
163
|
+
stale = sorted(
|
|
164
|
+
path
|
|
165
|
+
for path, text in wanted.items()
|
|
166
|
+
if (files.read(path, []) if files.is_file(path) else None) != text
|
|
167
|
+
)
|
|
168
|
+
if stale:
|
|
169
|
+
return Check(
|
|
170
|
+
"agent tool files",
|
|
171
|
+
Status.WARNING,
|
|
172
|
+
f"{len(stale)} file(s) Waymark owns are missing or out of date, starting with "
|
|
173
|
+
f'{stale[0]}. Run "wm update", then review and commit the changes.',
|
|
174
|
+
)
|
|
175
|
+
return Check("agent tool files", Status.OK, "The skills, agents and hooks are current.")
|
|
176
|
+
|
|
177
|
+
|
|
178
|
+
def _reference_checks(record: Record, registry: Registry) -> list[Check]:
|
|
179
|
+
checks: list[Check] = []
|
|
180
|
+
for reference in record.config.references if record.config else ():
|
|
181
|
+
location = locate_atlas(reference.atlas, registry, record.project.root, reference.path_hint)
|
|
182
|
+
name = f"reference {reference.atlas}"
|
|
183
|
+
if location.found is Found.MISSING:
|
|
184
|
+
checks.append(Check(name, Status.WARNING, location.detail))
|
|
185
|
+
elif location.found is Found.HINT:
|
|
186
|
+
checks.append(Check(name, Status.WARNING, location.detail, location.folder))
|
|
187
|
+
else:
|
|
188
|
+
checks.append(Check(name, Status.OK, "Registered.", location.folder))
|
|
189
|
+
return checks
|
|
190
|
+
|
|
191
|
+
|
|
192
|
+
def doctor(start: Path) -> Report:
|
|
193
|
+
"""Check wm, git and the project around a folder."""
|
|
194
|
+
checks = [_wm_on_path(), _git()]
|
|
195
|
+
registry = load_registry()
|
|
196
|
+
if registry.problems:
|
|
197
|
+
checks.append(Check("registry", Status.ERROR, registry.problems[0], registry.path))
|
|
198
|
+
try:
|
|
199
|
+
project = find_project(start, registry)
|
|
200
|
+
except ProjectNotFoundError as error:
|
|
201
|
+
checks.append(Check("project", Status.ERROR, error.plain, start))
|
|
202
|
+
return Report("project", tuple(checks))
|
|
203
|
+
checks.append(_project_check(project))
|
|
204
|
+
checks.append(_hooks_check(project.root, optional=False))
|
|
205
|
+
if project.code_repo is not None:
|
|
206
|
+
checks.append(_hooks_check(project.code_repo, optional=True))
|
|
207
|
+
record = load_record(project)
|
|
208
|
+
checks += _pin_checks(record)
|
|
209
|
+
checks += _reference_checks(record, registry)
|
|
210
|
+
if record.config is not None and record.config.atlas_name is not None:
|
|
211
|
+
checks.append(
|
|
212
|
+
Check("atlas", Status.OK, 'This is an atlas. "wm atlas doctor" checks its code repos.')
|
|
213
|
+
)
|
|
214
|
+
return Report("project", tuple(checks))
|
|
215
|
+
|
|
216
|
+
|
|
217
|
+
def _registry_checks(atlas: str, root: Path, registry: Registry) -> list[Check]:
|
|
218
|
+
if registry.problems:
|
|
219
|
+
return [Check("registry", Status.ERROR, registry.problems[0], registry.path)]
|
|
220
|
+
checks = [Check("registry", Status.OK, "The registry can be read.", registry.path)]
|
|
221
|
+
entry = registry.atlas(atlas)
|
|
222
|
+
if entry is None or entry.path is None:
|
|
223
|
+
checks.append(
|
|
224
|
+
Check(
|
|
225
|
+
"atlas registered",
|
|
226
|
+
Status.WARNING,
|
|
227
|
+
f'The atlas "{atlas}" is not registered on this machine. Run "wm atlas register" '
|
|
228
|
+
"in it.",
|
|
229
|
+
)
|
|
230
|
+
)
|
|
231
|
+
elif entry.path.resolve() != root.resolve():
|
|
232
|
+
checks.append(
|
|
233
|
+
Check(
|
|
234
|
+
"atlas registered",
|
|
235
|
+
Status.WARNING,
|
|
236
|
+
f'The registry has the atlas "{atlas}" at another folder, shown below. Run '
|
|
237
|
+
'"wm atlas register" here if this is the one to use.',
|
|
238
|
+
entry.path,
|
|
239
|
+
)
|
|
240
|
+
)
|
|
241
|
+
else:
|
|
242
|
+
checks.append(Check("atlas registered", Status.OK, f'"{atlas}" is registered.', root))
|
|
243
|
+
return checks
|
|
244
|
+
|
|
245
|
+
|
|
246
|
+
def _pointer_check(name: str, folder: Path, atlas: str, pin: str) -> Check | None:
|
|
247
|
+
pointer, problem = read_pointer(folder)
|
|
248
|
+
if problem is not None:
|
|
249
|
+
return Check(f"pointer {name}", Status.ERROR, problem, folder)
|
|
250
|
+
if pointer is None:
|
|
251
|
+
return None
|
|
252
|
+
if pointer.wm_version not in (None, pin):
|
|
253
|
+
return Check(
|
|
254
|
+
f"pointer {name}",
|
|
255
|
+
Status.WARNING,
|
|
256
|
+
f"Its {POINTER_FILE} pins wm {pointer.wm_version}; the atlas pins {pin}. Run "
|
|
257
|
+
f'"wm atlas point {atlas}" in it to bring the pointer up to date.',
|
|
258
|
+
folder,
|
|
259
|
+
)
|
|
260
|
+
return Check(f"pointer {name}", Status.OK, f'{POINTER_FILE} names "{atlas}".', folder)
|
|
261
|
+
|
|
262
|
+
|
|
263
|
+
def _repo_checks(record: Record, registry: Registry) -> list[Check]:
|
|
264
|
+
config = record.config
|
|
265
|
+
assert config is not None
|
|
266
|
+
assert config.atlas_name is not None
|
|
267
|
+
atlas, root = config.atlas_name, record.project.root
|
|
268
|
+
checks: list[Check] = []
|
|
269
|
+
for repo in config.repos:
|
|
270
|
+
location = locate_repo(atlas, root, repo, registry)
|
|
271
|
+
name = f"repo {repo.name}"
|
|
272
|
+
if location.folder is None:
|
|
273
|
+
checks.append(Check(name, Status.WARNING, location.detail))
|
|
274
|
+
continue
|
|
275
|
+
branch = git.current_branch(location.folder)
|
|
276
|
+
where = f"on branch {branch}" if branch else "with no branch checked out"
|
|
277
|
+
status = Status.OK if location.found is Found.REGISTRY else Status.WARNING
|
|
278
|
+
message = f"Found, {where}." + (f" {location.detail}" if location.detail else "")
|
|
279
|
+
checks.append(Check(name, status, message, location.folder))
|
|
280
|
+
pointer = _pointer_check(repo.name, location.folder, atlas, config.wm_version)
|
|
281
|
+
if pointer is not None:
|
|
282
|
+
checks.append(pointer)
|
|
283
|
+
entry = registry.atlas(atlas)
|
|
284
|
+
for leftover in sorted(set(entry.repos) - config.repo_names) if entry else ():
|
|
285
|
+
checks.append(
|
|
286
|
+
Check(
|
|
287
|
+
f"repo {leftover}",
|
|
288
|
+
Status.WARNING,
|
|
289
|
+
f'The registry has a code repo "{leftover}" that the atlas\'s settings no longer '
|
|
290
|
+
"list. It does no harm; remove it from the registry file if it is gone for good.",
|
|
291
|
+
)
|
|
292
|
+
)
|
|
293
|
+
return checks
|
|
294
|
+
|
|
295
|
+
|
|
296
|
+
def _local_files_check(record: Record, registry: Registry) -> Check:
|
|
297
|
+
config = record.config
|
|
298
|
+
assert config is not None
|
|
299
|
+
assert config.atlas_name is not None
|
|
300
|
+
folders = [
|
|
301
|
+
location.folder
|
|
302
|
+
for repo in config.repos
|
|
303
|
+
if (location := locate_repo(config.atlas_name, record.project.root, repo, registry)).folder
|
|
304
|
+
is not None
|
|
305
|
+
]
|
|
306
|
+
files = RecordFiles(record.project.root)
|
|
307
|
+
try:
|
|
308
|
+
wanted = integration.local_files(files, config.agent_tools, folders)
|
|
309
|
+
except Refusal as refusal:
|
|
310
|
+
return Check("attached repos", Status.ERROR, str(refusal))
|
|
311
|
+
stale = sorted(
|
|
312
|
+
path
|
|
313
|
+
for path, text in wanted.items()
|
|
314
|
+
if (files.read(path, []) if files.is_file(path) else None) != text
|
|
315
|
+
)
|
|
316
|
+
if stale:
|
|
317
|
+
return Check(
|
|
318
|
+
"attached repos",
|
|
319
|
+
Status.WARNING,
|
|
320
|
+
f"{stale[0]} doesn't attach every code repo found on this machine to the agent "
|
|
321
|
+
'tool\'s sessions. Run "wm atlas register" to attach them.',
|
|
322
|
+
)
|
|
323
|
+
return Check("attached repos", Status.OK, "The code repos found are attached to sessions.")
|
|
324
|
+
|
|
325
|
+
|
|
326
|
+
def atlas_doctor(start: Path) -> Report:
|
|
327
|
+
"""Check an atlas's setup on this machine: registry, paths, branches and pins."""
|
|
328
|
+
registry = load_registry()
|
|
329
|
+
try:
|
|
330
|
+
project = find_project(start, registry)
|
|
331
|
+
except ProjectNotFoundError as error:
|
|
332
|
+
return Report("atlas", (Check("project", Status.ERROR, error.plain, start),))
|
|
333
|
+
record = load_record(project)
|
|
334
|
+
config = record.config
|
|
335
|
+
if config is None or config.atlas_name is None:
|
|
336
|
+
message = (
|
|
337
|
+
"This project keeps its record in its own repository; it is not an atlas."
|
|
338
|
+
if config is not None
|
|
339
|
+
else f"{RECORD_DIR}/{CONFIG_FILE} can't be read; run wm check."
|
|
340
|
+
)
|
|
341
|
+
return Report("atlas", (Check("atlas", Status.ERROR, message, project.root),))
|
|
342
|
+
checks = [Check("atlas", Status.OK, f'The atlas "{config.atlas_name}".', project.root)]
|
|
343
|
+
checks += _registry_checks(config.atlas_name, project.root, registry)
|
|
344
|
+
if config.wm_version != __version__:
|
|
345
|
+
checks.append(
|
|
346
|
+
Check(
|
|
347
|
+
"version pin",
|
|
348
|
+
Status.ERROR,
|
|
349
|
+
f"The atlas pins wm {config.wm_version}, and this is wm {__version__}. "
|
|
350
|
+
f"Install the pinned version: {install_hint(config.wm_version)}",
|
|
351
|
+
)
|
|
352
|
+
)
|
|
353
|
+
else:
|
|
354
|
+
checks.append(Check("version pin", Status.OK, f"Pinned to wm {config.wm_version}."))
|
|
355
|
+
branch = git.current_branch(project.root)
|
|
356
|
+
checks.append(
|
|
357
|
+
Check(
|
|
358
|
+
"atlas branch",
|
|
359
|
+
Status.OK if branch else Status.WARNING,
|
|
360
|
+
f"On branch {branch}." if branch else "No branch is checked out in the atlas.",
|
|
361
|
+
project.root,
|
|
362
|
+
)
|
|
363
|
+
)
|
|
364
|
+
if not registry.problems:
|
|
365
|
+
checks += _repo_checks(record, registry)
|
|
366
|
+
checks.append(_local_files_check(record, registry))
|
|
367
|
+
return Report("atlas", tuple(checks))
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
"""The git hooks: installing them, and the two checks they run.
|
|
2
|
+
|
|
3
|
+
``commit-msg`` checks the message's conventional-commit format, with the
|
|
4
|
+
project's scopes when it lists any. ``pre-commit`` runs the health check when
|
|
5
|
+
the commit changes the record. Both are installed into ``.waymark/hooks/``
|
|
6
|
+
and run through ``core.hooksPath``; a repository with another hook manager is
|
|
7
|
+
told what to add instead.
|
|
8
|
+
"""
|
|
9
|
+
|
|
10
|
+
import datetime
|
|
11
|
+
from pathlib import Path
|
|
12
|
+
|
|
13
|
+
from waymark.record import git
|
|
14
|
+
from waymark.record.commits import commit_problem
|
|
15
|
+
from waymark.record.config import CONFIG_FILE, RECORD_DIR, parse_config
|
|
16
|
+
from waymark.record.files import RecordFiles
|
|
17
|
+
from waymark.record.githooks import (
|
|
18
|
+
ATTRIBUTES,
|
|
19
|
+
HOOKS,
|
|
20
|
+
HOOKS_DIR,
|
|
21
|
+
hook_files,
|
|
22
|
+
hook_manager,
|
|
23
|
+
hook_scripts,
|
|
24
|
+
make_executable,
|
|
25
|
+
read_message,
|
|
26
|
+
)
|
|
27
|
+
from waymark.record.project import Project, ProjectNotFoundError, find_project
|
|
28
|
+
from waymark.record.record import load_record
|
|
29
|
+
from waymark.record.store import Transaction
|
|
30
|
+
from waymark.services.check import Severity, check_record
|
|
31
|
+
from waymark.services.common import Done, Refusal, commit
|
|
32
|
+
|
|
33
|
+
COMMANDS = {
|
|
34
|
+
"commit-msg": 'wm run-hook commit-msg "$1"',
|
|
35
|
+
"pre-commit": "wm run-hook pre-commit",
|
|
36
|
+
}
|
|
37
|
+
"""What each hook runs, for a hook manager to call."""
|
|
38
|
+
|
|
39
|
+
_SHOWN = 5
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def install(root: Path) -> list[str]:
|
|
43
|
+
"""Write the committed hooks into a repository and point this clone's git at them.
|
|
44
|
+
|
|
45
|
+
A repository that already uses another hook setup is not taken over; the
|
|
46
|
+
lines say what to add to it instead.
|
|
47
|
+
"""
|
|
48
|
+
manager = hook_manager(root)
|
|
49
|
+
if manager is not None:
|
|
50
|
+
manual = [f"Git hooks: not installed, because {manager}. Add these to it instead:"]
|
|
51
|
+
return manual + [f" {name}: {command}" for name, command in COMMANDS.items()]
|
|
52
|
+
files = RecordFiles(root)
|
|
53
|
+
transaction = Transaction(files)
|
|
54
|
+
lines: list[str] = []
|
|
55
|
+
for path, text in sorted(hook_files().items()):
|
|
56
|
+
current = files.read(path, []) if files.is_file(path) else None
|
|
57
|
+
if current != text:
|
|
58
|
+
transaction.write(path, text)
|
|
59
|
+
lines.append(f"{'created' if current is None else 'updated'}: {path}")
|
|
60
|
+
commit(transaction)
|
|
61
|
+
make_executable(root)
|
|
62
|
+
git.stage(root, [ATTRIBUTES])
|
|
63
|
+
git.stage_executable(root, sorted(hook_scripts()))
|
|
64
|
+
if git.config_value(root, "core.hooksPath") != HOOKS_DIR:
|
|
65
|
+
git.set_config(root, "core.hooksPath", HOOKS_DIR)
|
|
66
|
+
lines.append(f"Git in this clone now runs the hooks in {HOOKS_DIR}/ (core.hooksPath).")
|
|
67
|
+
if lines:
|
|
68
|
+
lines.append(
|
|
69
|
+
f"The hooks in {HOOKS_DIR}/ are staged with their executable bit; commit them so "
|
|
70
|
+
"every clone gets them."
|
|
71
|
+
)
|
|
72
|
+
return lines
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def git_hooks(start: Path) -> Done:
|
|
76
|
+
"""Install the committed hooks in the git repository around a folder."""
|
|
77
|
+
root = git.repository_root(start)
|
|
78
|
+
if root is None:
|
|
79
|
+
raise Refusal("Git hooks go in a git repository, and this folder is not in one.")
|
|
80
|
+
lines = install(root)
|
|
81
|
+
return Done("\n".join(lines) or "The git hooks are installed and in use.")
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
def _scopes(start: Path) -> tuple[str, ...] | None:
|
|
85
|
+
"""The project's commit scopes, if it lists any; None means any scope is accepted."""
|
|
86
|
+
try:
|
|
87
|
+
project = find_project(start)
|
|
88
|
+
except ProjectNotFoundError:
|
|
89
|
+
return None
|
|
90
|
+
text = RecordFiles(project.record_root).read(CONFIG_FILE, [])
|
|
91
|
+
config = parse_config(text)[0] if text is not None else None
|
|
92
|
+
return config.commit_scopes if config else None
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def check_commit_message(start: Path, message_file: str) -> Done:
|
|
96
|
+
"""The commit-msg hook: refuse a message that isn't a conventional commit."""
|
|
97
|
+
path = Path(message_file)
|
|
98
|
+
message = read_message(path if path.is_absolute() else start / path)
|
|
99
|
+
problem = commit_problem(message, _scopes(start))
|
|
100
|
+
if problem is not None:
|
|
101
|
+
raise Refusal(f"The commit was stopped: {problem}")
|
|
102
|
+
return Done("")
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
def check_staged_record(start: Path, now: datetime.datetime) -> Done:
|
|
106
|
+
"""The pre-commit hook: when the commit changes the record, refuse it while wm check fails.
|
|
107
|
+
|
|
108
|
+
The record's files are checked as they are on disk.
|
|
109
|
+
"""
|
|
110
|
+
root = git.repository_root(start)
|
|
111
|
+
if root is None or not (root / RECORD_DIR / CONFIG_FILE).is_file():
|
|
112
|
+
return Done("")
|
|
113
|
+
staged = git.staged_paths(root)
|
|
114
|
+
if not any(path.startswith(f"{RECORD_DIR}/") for path in staged):
|
|
115
|
+
return Done("")
|
|
116
|
+
findings = check_record(load_record(Project(root)), now)
|
|
117
|
+
errors = [finding for finding in findings if finding.severity is Severity.ERROR]
|
|
118
|
+
if not errors:
|
|
119
|
+
return Done("")
|
|
120
|
+
lines = [
|
|
121
|
+
f"- {RECORD_DIR}/{e.path}{f':{e.line}' if e.line else ''}: {e.message}"
|
|
122
|
+
for e in errors[:_SHOWN]
|
|
123
|
+
]
|
|
124
|
+
more = f"\n... and {len(errors) - _SHOWN} more." if len(errors) > _SHOWN else ""
|
|
125
|
+
raise Refusal(
|
|
126
|
+
f"The commit was stopped: it changes the record, and wm check finds {len(errors)} "
|
|
127
|
+
"error(s):\n" + "\n".join(lines) + more + '\nFix them, then commit again; "wm check" '
|
|
128
|
+
"lists them all."
|
|
129
|
+
)
|
|
130
|
+
|
|
131
|
+
|
|
132
|
+
HOOK_NAMES = tuple(HOOKS)
|