Store a record on the Confluence Cloud page its config names, and refuse to overwrite a teammate's save
CI / tests (pull_request) Failing after 1m54s
CI / tests (pull_request) Failing after 1m54s
This commit is contained in:
@@ -2,6 +2,7 @@
|
||||
|
||||
## Unreleased
|
||||
|
||||
- A project's config may keep each of its five records on a Confluence Cloud page: set, for example, `decisions = "confluence:https://<site>/wiki/spaces/<space>/pages/<page ID>"`, with the credentials in the config's `env-file`. The loop reads and writes the page as markdown. It never overwrites a teammate's edit: where someone saved the page since the loop read it, `project-record save` refuses and the loop asks you.
|
||||
- `todo-item add` files an item into a plan kept in a Jira epic: a Task under the epic, under the project's Fix Version for the release, labelled `security` for a security finding and linked to each item that blocks it. Editing and finishing an issue still happen in Jira.
|
||||
- An item of the next release may predict the files and parts it will touch, under a `Touches:` line in its detail. `chunk-preflight` then names the items that may start chunks at once, and the new `touch-predictions record` keeps each prediction beside what the merged chunk touched, in the record a project's config places with `touch-predictions`.
|
||||
- CLAUDE.md and the todo-items rule define the plan as a todo.md or a Jira epic, and say plan where todo.md was false for a Jira plan.
|
||||
|
||||
@@ -202,10 +202,10 @@ Install puts only `loop-claude` on `PATH`; call the others by their path, such a
|
||||
- `notifier/` sends the human a DM through the notifier a project's config names, for `notify` and for loop-claude through `loop_effects`; `mattermost_dm/` and `slack_dm/` are its two backends.
|
||||
- `plan_store/` reads and writes a project's plan through the store the project's config names (`stores.py`), with the markdown file's edits in `markdown_edits.py`. `contract.py` holds the tests every backend that writes must pass, which `jira_epic.py` doesn't yet, and `fakes.py` a plan in memory.
|
||||
- `rank_todo.py`, `settings_filter.py` and `statusline.py` are tools of one file each, tested beside them.
|
||||
- `record_store/` reads and writes a project's records, each through the store the project's config names (`stores.py`). `contract.py` holds the tests every backend must pass, and `fakes.py` a store in memory that the tests of other tools use.
|
||||
- `record_store/` reads and writes a project's records, each through the store the project's config names (`stores.py`): a markdown file, a Confluence Cloud page (`confluence_page.py`), or, for the goals, a Jira epic's description (`jira_description.py`). `contract.py` holds the tests every backend must pass, and `fakes.py` a store in memory that the tests of other tools use.
|
||||
- `release_plan/` reads `todo.md`'s items table and release versions, says which release is next and whether it is ready to cut (`release_standing.py`), and ranks the plan (`ranking.py`, with its score formula in `formula.py` and its blocker order in `blockers.py`). `goals_file.py` reads the goals file's sections, goals and goal weights, for the ranking and for `loop_claude`'s premises, and `citations.py` holds `todo.md` and `docs/decisions.md` to each other. `plan_file.py` ranks, checks and writes a `todo.md`, for `larv_review`, `rank_todo.py` and `rule_hook`.
|
||||
- `repo_checks/` tests the repo itself.
|
||||
- `rest_client/` sends a JSON request to a REST API and reads its credentials from an env file, for `mattermost_dm`, `slack_dm` and `plan_store`.
|
||||
- `rest_client/` sends a JSON request to a REST API and reads its credentials from an env file, for `mattermost_dm`, `slack_dm`, `plan_store` and `record_store`.
|
||||
- `review_rules/` holds the larv-review rules that several tools apply: its passes, its review folder, its round commit titles and the comprehension history's format.
|
||||
- `routing_figures/` measures loop-claude's archive, and each of its projects' default branches, for loop-claude's routing calls.
|
||||
- `rung_replay/` holds what `judge_replay` and `review_replay` share: the parallel replay runner, the argument reader, the candidate rungs and the exits, and `judge_replay`'s rung search. It reads `loop_claude`'s retry count and models file, and finds that file through `loop_state`'s paths.
|
||||
|
||||
@@ -31,6 +31,13 @@ epic's description is then the goals file, with ## Goals and ## Audience as head
|
||||
`project-config goals-and-audience` prints the setting as the config spells it. The description is
|
||||
only read: edit it in Jira.
|
||||
|
||||
Each record, `decisions`, `score-anchors`, `comprehension-history`, `reading-cost` and `changelog`,
|
||||
may name a Confluence Cloud page in place of a path, as "confluence:" and the page's address, with or
|
||||
without the title at its end: "confluence:https://acme.atlassian.net/wiki/spaces/ENG/pages/2293761".
|
||||
The record is then that page's text, which `project-record` reads and writes as markdown, and
|
||||
`project-config <record>` prints the setting as the config spells it. Such a config must set
|
||||
`env-file`, holding ATLASSIAN_EMAIL and ATLASSIAN_API_TOKEN, as for a Jira epic.
|
||||
|
||||
`env-file` is an optional setting: the file of KEY=value credentials the project's tools read,
|
||||
a path that starts with / or ~/ and lies outside the checkout and the config's folder, such as
|
||||
"~/.claude-projects/acme-billing.env". Where it is left out, the project has no credentials file, and
|
||||
|
||||
@@ -46,6 +46,10 @@ EPIC_SPELLINGS = {
|
||||
"goals-and-audience": '"jira:https://<site>/browse/<epic\'s key>" for goals and audience kept in a Jira Cloud epic\'s description',
|
||||
"plan": '"jira:https://<site>/browse/<epic\'s key>" for a plan kept as a Jira Cloud epic\'s child issues',
|
||||
}
|
||||
# The settings that each name a record, a document a project keeps beside its plan. Each may name a Confluence Cloud page in place of a path: `confluence:`, then the page's address as the browser shows it, whose last part, the title, may be left out. Three readers, seated as the human who writes the config, picked that spelling over the bare address, a page ID beside a site setting, and a table.
|
||||
RECORDS = ("decisions", "score-anchors", "comprehension-history", "reading-cost", "changelog")
|
||||
CONFLUENCE = "confluence:"
|
||||
PAGE_SPELLING = '"confluence:https://<site>/wiki/spaces/<space>/pages/<page ID>" for a record kept on a Confluence Cloud page'
|
||||
OUTSIDE = "a path that starts with / or ~/ and lies outside the checkout and the config's folder, so that no git remote receives the credentials"
|
||||
|
||||
|
||||
@@ -66,9 +70,17 @@ class Epic:
|
||||
return f"{JIRA}{self.site}/browse/{self.key}"
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Page:
|
||||
"""A Confluence Cloud page: site is its site's address, such as https://acme.atlassian.net, page_id its number, and spelling the setting's value as the config writes it."""
|
||||
site: str
|
||||
page_id: str
|
||||
spelling: str
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class ProjectConfig:
|
||||
"""folder is `~/.claude-projects/<key>`, top is the worktree that asked, and paths holds each of SETTINGS as an absolute path, except `plan` and `goals-and-audience` where they are kept in Jira."""
|
||||
"""folder is `~/.claude-projects/<key>`, top is the worktree that asked, and paths holds each of SETTINGS as an absolute path, except `plan` and `goals-and-audience` where they are kept in Jira, and each record kept on a Confluence page."""
|
||||
key: str
|
||||
folder: pathlib.Path
|
||||
top: pathlib.Path
|
||||
@@ -88,6 +100,8 @@ class ProjectConfig:
|
||||
goals_epic: Epic | None = None
|
||||
# The config's `notifier`, or None where it names none.
|
||||
notifier: Notifier | None = None
|
||||
# The Confluence page of each record the config keeps on one, by the record's setting.
|
||||
pages: dict[str, Page] = dataclasses.field(default_factory=dict)
|
||||
|
||||
@property
|
||||
def plan_file(self) -> pathlib.Path | None:
|
||||
@@ -101,9 +115,9 @@ class ProjectConfig:
|
||||
|
||||
@property
|
||||
def places(self) -> dict[str, str]:
|
||||
"""Where each of SETTINGS is kept, in SETTINGS' order, then TOUCH_PREDICTIONS where the config sets it: a path, or the epic as the config spells it."""
|
||||
epics = {"plan": self.epic, "goals-and-audience": self.goals_epic}
|
||||
return {name: epic.spelling if (epic := epics.get(name)) else str(self.paths[name]) for name in (*SETTINGS, TOUCH_PREDICTIONS) if epics.get(name) or name in self.paths}
|
||||
"""Where each of SETTINGS is kept, in SETTINGS' order, then TOUCH_PREDICTIONS where the config sets it: a path, or the epic or page as the config spells it."""
|
||||
spelt = {name: kept.spelling for name, kept in {"plan": self.epic, "goals-and-audience": self.goals_epic, **self.pages}.items() if kept}
|
||||
return {name: spelt[name] if name in spelt else str(self.paths[name]) for name in (*SETTINGS, TOUCH_PREDICTIONS) if name in spelt or name in self.paths}
|
||||
|
||||
@property
|
||||
def texts(self) -> dict[str, str]:
|
||||
@@ -142,6 +156,7 @@ def load(top: pathlib.Path, main: pathlib.Path, home: pathlib.Path) -> ProjectCo
|
||||
file, values = named[0]
|
||||
paths = {name: placed(values[name], top, file.parent, home) for name in (*SETTINGS, TOUCH_PREDICTIONS) if name in values}
|
||||
epics = {name: epic_of(values.get(name)) for name in EPIC_SPELLINGS}
|
||||
pages = {name: page for name in RECORDS if (page := page_of(values.get(name)))}
|
||||
env_file = anywhere(values.get(ENV_FILE), home)
|
||||
misplaced = ENV_FILE in values and (env_file is None or lies_in(env_file, top, main, file.parent))
|
||||
notifier = next((name for name in NOTIFIERS if name == values.get(NOTIFIER)), None)
|
||||
@@ -152,9 +167,11 @@ def load(top: pathlib.Path, main: pathlib.Path, home: pathlib.Path) -> ProjectCo
|
||||
faults = [
|
||||
*(f"`{name}` is missing" for name in SETTINGS if name not in values),
|
||||
*(f"`{name}` is not a setting" for name in values if name not in (*SETTINGS, *OPTIONAL)),
|
||||
*(f"`{name}` is {values[name]!r}, not {SPELLING}" for name, path in paths.items() if path is None and name not in EPIC_SPELLINGS),
|
||||
*(f"`{name}` is {values[name]!r}, not {SPELLING}" for name, path in paths.items() if path is None and name not in (*EPIC_SPELLINGS, *RECORDS)),
|
||||
*(f"`{name}` is {values[name]!r}, not {SPELLING}, or {EPIC_SPELLINGS[name]}" for name in EPIC_SPELLINGS if name in values and paths[name] is None and epics[name] is None),
|
||||
*(f"`{name}` is {values[name]!r}, not {SPELLING}, or {PAGE_SPELLING}" for name in RECORDS if name in values and paths[name] is None and name not in pages),
|
||||
*(f"`{name}` names a Jira epic, so `{ENV_FILE}` must name the file that holds its credentials" for name, epic in epics.items() if epic and ENV_FILE not in values),
|
||||
*(f"`{name}` names a Confluence page, so `{ENV_FILE}` must name the file that holds its credentials" for name in pages if ENV_FILE not in values),
|
||||
# rule-hook ranks a plan kept as a file before tool calls, inside the hook's time limit, which a read from Jira mustn't hold up.
|
||||
*(["`goals-and-audience` names a Jira epic, so `plan` must name one too"] if epics["goals-and-audience"] and not epics["plan"] else []),
|
||||
*([f"`{ENV_FILE}` is {values[ENV_FILE]!r}, not {OUTSIDE}"] if misplaced else []),
|
||||
@@ -168,7 +185,7 @@ def load(top: pathlib.Path, main: pathlib.Path, home: pathlib.Path) -> ProjectCo
|
||||
return Failure(f"{file}: {'; '.join(faults)}. The settings are {', '.join(SETTINGS)}, and optionally {', '.join(OPTIONAL[:-1])} and {OPTIONAL[-1]}.")
|
||||
# faults names a floor the config misspells.
|
||||
assert floor is not None
|
||||
return ProjectConfig(file.parent.name, file.parent, top, {name: path for name, path in paths.items() if path}, env_file, waits is True, on_host is True, floor, **{name.replace("-", "_"): str(values[name]) for name in checks if name in values}, epic=epics["plan"], goals_epic=epics["goals-and-audience"], notifier=notifier)
|
||||
return ProjectConfig(file.parent.name, file.parent, top, {name: path for name, path in paths.items() if path}, env_file, waits is True, on_host is True, floor, **{name.replace("-", "_"): str(values[name]) for name in checks if name in values}, epic=epics["plan"], goals_epic=epics["goals-and-audience"], notifier=notifier, pages=pages)
|
||||
|
||||
|
||||
def epic_of(value: object) -> Epic | None:
|
||||
@@ -177,6 +194,12 @@ def epic_of(value: object) -> Epic | None:
|
||||
return Epic(spelt.group(1), spelt.group(2)) if spelt else None
|
||||
|
||||
|
||||
def page_of(value: object) -> Page | None:
|
||||
"""The page a setting's value spells; None where it spells none. Only https, as for an epic."""
|
||||
spelt = isinstance(value, str) and re.fullmatch(rf"{CONFLUENCE}(https://[A-Za-z0-9.-]+(?::[0-9]+)?)/wiki/spaces/[^/?#]+/pages/([0-9]+)(?:/[^/?#]*)?", value)
|
||||
return Page(spelt.group(1), spelt.group(2), spelt.string) if spelt else None
|
||||
|
||||
|
||||
def floor_of(value: object) -> decimal.Decimal | None:
|
||||
"""The floor value spells, an integer or a float from 1 to 10; None where it spells none. Not a string, nor a boolean, which Python counts as an integer, nor TOML's nan or inf."""
|
||||
# An integer too large for a float makes math.isfinite raise, so only a float is checked.
|
||||
|
||||
@@ -9,7 +9,7 @@ import unittest.mock
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from project_config.settings import env_files, Epic, held, load, NOTIFIERS, OUTSIDE, ProjectConfig, SETTINGS, Unnamed
|
||||
from project_config.settings import env_files, Epic, held, load, NOTIFIERS, OUTSIDE, Page, ProjectConfig, SETTINGS, Unnamed
|
||||
from failure import Failure
|
||||
from test_env import isolated_env
|
||||
from project_config.main import title_templates
|
||||
@@ -31,6 +31,7 @@ principles = "~/.claude/principles"
|
||||
|
||||
JIRA_PLAN = "jira:https://acme.atlassian.net/browse/ABC-12"
|
||||
JIRA_CLIENT = CLIENT.replace("folder:todo.md", JIRA_PLAN) + 'env-file = "~/acme.env"\n'
|
||||
DECISIONS_PAGE = "confluence:https://acme.atlassian.net/wiki/spaces/ENG/pages/2293761/Decisions"
|
||||
|
||||
|
||||
def write_config(home: pathlib.Path, checkout: pathlib.Path, goals: str = "checkout:README.md") -> pathlib.Path:
|
||||
@@ -153,6 +154,47 @@ class LoadTest(ConfigCase):
|
||||
self.assertIn("jira:https://<site>/browse/<epic's key>", reason)
|
||||
self.assertIn("description", reason)
|
||||
|
||||
def test_a_record_spelt_as_a_confluence_page_is_no_path_and_prints_as_written(self) -> None:
|
||||
self.write("acme", CLIENT.replace("folder:docs/decisions.md", DECISIONS_PAGE) + 'env-file = "~/acme.env"\n')
|
||||
found = load(self.checkout, self.checkout, self.home)
|
||||
assert isinstance(found, ProjectConfig), found
|
||||
self.assertEqual(found.pages, {"decisions": Page("https://acme.atlassian.net", "2293761", DECISIONS_PAGE)})
|
||||
self.assertEqual(found.places["decisions"], DECISIONS_PAGE)
|
||||
self.assertEqual(tuple(found.places), SETTINGS)
|
||||
self.assertNotIn("decisions", found.paths)
|
||||
self.assertIsNone(found.tracked("decisions"))
|
||||
|
||||
def test_a_confluence_page_may_leave_out_its_title(self) -> None:
|
||||
for spelled in ("confluence:https://acme.atlassian.net/wiki/spaces/ENG/pages/2293761", "confluence:https://acme.atlassian.net/wiki/spaces/~5b1e/pages/2293761/R%C3%A5d+och+beslut"):
|
||||
with self.subTest(spelled):
|
||||
for config in (self.home / ".claude-projects").glob("*/config.toml"):
|
||||
config.unlink()
|
||||
config.parent.rmdir()
|
||||
self.write("acme", CLIENT.replace("checkout:CHANGELOG.md", spelled) + 'env-file = "~/acme.env"\n')
|
||||
found = load(self.checkout, self.checkout, self.home)
|
||||
assert isinstance(found, ProjectConfig), found
|
||||
self.assertEqual(found.pages["changelog"].page_id, "2293761")
|
||||
|
||||
def test_a_confluence_record_needs_an_env_file(self) -> None:
|
||||
self.write("acme", CLIENT.replace("folder:docs/decisions.md", DECISIONS_PAGE))
|
||||
self.assertIn("`decisions` names a Confluence page, so `env-file` must name the file that holds its credentials", self.failure())
|
||||
|
||||
def test_a_record_that_spells_no_path_and_no_page_names_both_spellings(self) -> None:
|
||||
for count, spelled in enumerate(("confluence:http://acme.atlassian.net/wiki/spaces/ENG/pages/2293761", "confluence:https://acme.atlassian.net/wiki/spaces/ENG/pages/Decisions", "confluence:https://acme.atlassian.net@evil.example/wiki/spaces/ENG/pages/2293761", "confluence:2293761", "https://acme.atlassian.net/wiki/spaces/ENG/pages/2293761")):
|
||||
with self.subTest(spelled):
|
||||
self.write(f"acme-{count}", CLIENT.replace("folder:docs/decisions.md", spelled) + 'env-file = "~/acme.env"\n')
|
||||
reason = self.failure()
|
||||
self.assertIn(f"`decisions` is {spelled!r}, not ", reason)
|
||||
self.assertIn("confluence:https://<site>/wiki/spaces/<space>/pages/<page ID>", reason)
|
||||
for config in (self.home / ".claude-projects").glob("*/config.toml"):
|
||||
config.unlink()
|
||||
|
||||
def test_only_a_record_may_name_a_confluence_page(self) -> None:
|
||||
self.write("acme", CLIENT.replace('"folder:AGENTS.md"', '"' + DECISIONS_PAGE + '"') + 'env-file = "~/acme.env"\n')
|
||||
reason = self.failure()
|
||||
self.assertIn("`working-rules` is", reason)
|
||||
self.assertNotIn("confluence:https://<site>", reason)
|
||||
|
||||
def test_a_worktree_finds_the_main_checkouts_config_and_reads_its_own_files(self) -> None:
|
||||
self.write("acme", CLIENT)
|
||||
worktree = self.home / "code" / "acme-billing-item-3"
|
||||
|
||||
@@ -14,7 +14,9 @@ path is a copy under ~/.local/state/project-record/<key>/, written afresh with t
|
||||
stands, so open it again before each edit. A record that doesn't exist yet has no file at the path:
|
||||
create it there.
|
||||
|
||||
save stores the file's text in the record, and prints one line saying so. Where the record is kept
|
||||
save stores the file's text in the record, and prints one line saying so. A record kept on a
|
||||
Confluence page is saved as the version after the one open read; where a teammate saved the page
|
||||
since, save refuses, and the human decides what follows. Where the record is kept
|
||||
as a file there is nothing left to store, and it says that. Run it after every edit, so the same
|
||||
steps work wherever a project keeps the record.
|
||||
|
||||
@@ -44,7 +46,7 @@ def main(argv: list[str]) -> int:
|
||||
return 2
|
||||
home = pathlib.Path.home()
|
||||
config = located(None, home)
|
||||
done = config if isinstance(config, Failure) else act(argv[0], goals_store(config) if argv[1] == GOALS else store(config, argv[1]), home / COPIES / config.key / f"{argv[1]}.md")
|
||||
done = config if isinstance(config, Failure) else act(argv[0], goals_store(config) if argv[1] == GOALS else store(config, argv[1], home / COPIES / config.key / f"{argv[1]}.version"), home / COPIES / config.key / f"{argv[1]}.md")
|
||||
if isinstance(done, Failure):
|
||||
print(f"project-record: {done.reason}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
"""A record kept on one Confluence Cloud page, read and written as markdown over Confluence's REST API version 2, with the credentials of the config's env-file, and converted by the adf-codec shim.
|
||||
|
||||
A write never overwrites a teammate's edit: it sends the version it read, and Confluence refuses it where someone saved the page since. The human then decides (lilleman, 2026-11-12)."""
|
||||
import dataclasses
|
||||
import json
|
||||
import pathlib
|
||||
import typing
|
||||
|
||||
from adf_codec.convert import adfs_to_markdown, markdown_to_adf, Refused
|
||||
from failure import Failure
|
||||
from plan_store.jira_epic import basic_auth, Http, ToAdf, ToMarkdown, TIMEOUT
|
||||
from project_config.settings import Page
|
||||
from rest_client import json_request
|
||||
from rest_client.json_request import ErrorAnswer
|
||||
from text_files.file_writes import replace_file
|
||||
|
||||
# What Confluence answers to a write whose version isn't the one after the version it holds.
|
||||
CONFLICT = 409
|
||||
SHAPE = "not in the shape Confluence Cloud's REST API version 2 documents"
|
||||
|
||||
|
||||
def http_json(method: str, url: str, authorization: str, body: object) -> object:
|
||||
return json_request.http_json(method, url, authorization, body, TIMEOUT, error_message)
|
||||
|
||||
|
||||
def error_message(answer: object) -> str:
|
||||
"""Confluence's messages in the JSON of an error answer; empty where it holds none."""
|
||||
errors = answer.get("errors") if isinstance(answer, dict) else None
|
||||
found = [error.get("title") for error in errors if isinstance(error, dict)] if isinstance(errors, list) else [answer.get("message")] if isinstance(answer, dict) else []
|
||||
return "; ".join(text for text in found if isinstance(text, str))
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Seen:
|
||||
"""The page's version number and title as the store last read or wrote them. A write needs both."""
|
||||
version: int
|
||||
title: str
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class ConfluencePage:
|
||||
"""The text of page as markdown, read and written with the credentials env_file holds.
|
||||
|
||||
kept is a file that keeps the version the store read for a later process, such as `project-record save` after `project-record open`; None keeps it only in memory."""
|
||||
page: Page
|
||||
env_file: pathlib.Path
|
||||
kept: pathlib.Path | None = None
|
||||
http: Http = http_json
|
||||
to_markdown: ToMarkdown = adfs_to_markdown
|
||||
to_adf: ToAdf = markdown_to_adf
|
||||
seen: Seen | None = None
|
||||
|
||||
@property
|
||||
def label(self) -> str:
|
||||
return self.page.spelling
|
||||
|
||||
@property
|
||||
def tracked(self) -> str | None:
|
||||
return None
|
||||
|
||||
@property
|
||||
def url(self) -> str:
|
||||
return f"{self.page.site}/wiki/api/v2/pages/{self.page.page_id}"
|
||||
|
||||
def read(self) -> str | Failure:
|
||||
"""The page's text as markdown; empty where the page is."""
|
||||
answer = self.fetched("?body-format=atlas_doc_format")
|
||||
if isinstance(answer, Failure):
|
||||
return answer
|
||||
seen, held = answer
|
||||
if not isinstance(held, str):
|
||||
return Failure(f"{self.label} is {SHAPE}: it holds no body in atlas_doc_format")
|
||||
if unkept := self.keep(seen):
|
||||
return unkept
|
||||
if not held:
|
||||
return ""
|
||||
try:
|
||||
document = json.loads(held)
|
||||
except ValueError:
|
||||
return Failure(f"{self.label} holds a body that is not JSON")
|
||||
texts = self.to_markdown([document])
|
||||
if isinstance(texts, Refused):
|
||||
return Failure(f"{self.label}: {texts.failure.reason}")
|
||||
if isinstance(texts, Failure):
|
||||
return Failure(f"cannot convert {self.label} to markdown: {texts.reason}")
|
||||
return texts[0]
|
||||
|
||||
def write(self, text: str) -> Failure | None:
|
||||
"""Replaces the page's text with text, as the version after the one the store read. A store that read nothing replaces the page as it stands."""
|
||||
seen = self.seen or self.recalled()
|
||||
if seen is None:
|
||||
fetched = self.fetched("")
|
||||
if isinstance(fetched, Failure):
|
||||
return fetched
|
||||
seen = fetched[0]
|
||||
if isinstance(seen, Failure):
|
||||
return seen
|
||||
document = self.to_adf(text)
|
||||
if isinstance(document, Failure):
|
||||
return Failure(f"cannot convert the text for {self.label} to ADF: {document.reason}")
|
||||
authorization = basic_auth(self.env_file)
|
||||
if isinstance(authorization, Failure):
|
||||
return authorization
|
||||
body = {"id": self.page.page_id, "status": "current", "title": seen.title, "body": {"representation": "atlas_doc_format", "value": json.dumps(document)}, "version": {"number": seen.version + 1}}
|
||||
answer = self.http("PUT", self.url, authorization, body)
|
||||
if isinstance(answer, ErrorAnswer) and answer.status == CONFLICT:
|
||||
return Failure(f"a teammate saved {self.label} since the loop read version {seen.version} of it, so the loop didn't write it: never overwrite their edit, but ask the human what to do ({answer.reason})")
|
||||
if isinstance(answer, Failure):
|
||||
return Failure(f"cannot write {self.label}: {answer.reason}")
|
||||
return self.keep(Seen(seen.version + 1, seen.title))
|
||||
|
||||
def fetched(self, query: str) -> tuple[Seen, object] | Failure:
|
||||
"""The page's version and title, and the value of its body in atlas_doc_format, which query asks for."""
|
||||
authorization = basic_auth(self.env_file)
|
||||
if isinstance(authorization, Failure):
|
||||
return authorization
|
||||
answer = self.http("GET", self.url + query, authorization, None)
|
||||
if isinstance(answer, Failure):
|
||||
return Failure(f"cannot read {self.label}: {answer.reason}")
|
||||
page = answer if isinstance(answer, dict) else {}
|
||||
version, title = page.get("version"), page.get("title")
|
||||
number = version.get("number") if isinstance(version, dict) else None
|
||||
if not isinstance(number, int) or not isinstance(title, str):
|
||||
return Failure(f"{self.label} is {SHAPE}: its version number or title is missing")
|
||||
body = page.get("body")
|
||||
adf = body.get("atlas_doc_format") if isinstance(body, dict) else None
|
||||
return Seen(number, title), adf.get("value") if isinstance(adf, dict) else None
|
||||
|
||||
def keep(self, seen: Seen) -> Failure | None:
|
||||
self.seen = seen
|
||||
if self.kept is None:
|
||||
return None
|
||||
try:
|
||||
self.kept.parent.mkdir(parents=True, exist_ok=True)
|
||||
except OSError as failure:
|
||||
return Failure(f"cannot write {self.kept}: {failure.strerror}")
|
||||
unwritten = replace_file(self.kept, json.dumps(dataclasses.asdict(seen)).encode())
|
||||
return Failure(f"cannot write {self.kept}: {unwritten.reason}") if unwritten else None
|
||||
|
||||
def recalled(self) -> Seen | Failure | None:
|
||||
"""The version and title kept's file holds; None where there is no such file."""
|
||||
if self.kept is None:
|
||||
return None
|
||||
try:
|
||||
held: typing.Any = json.loads(self.kept.read_text(encoding="utf-8"))
|
||||
return Seen(int(held["version"]), str(held["title"]))
|
||||
except FileNotFoundError:
|
||||
return None
|
||||
except (OSError, ValueError, KeyError, TypeError) as failure:
|
||||
return Failure(f"cannot read the version of {self.label} that {self.kept} keeps: {failure}")
|
||||
@@ -1,18 +1,15 @@
|
||||
"""The one way a tool reads or writes a project's records: through the store its config names for each.
|
||||
|
||||
Each record has its own setting in the config, so a project may keep one record in its wiki and another as a file. The setting's value names the backend. A path names a markdown file, the only backend of a record so far; the goals file may also be a Jira epic's description, which `goals_store` picks."""
|
||||
Each record has its own setting in the config, so a project may keep one record in its wiki and another as a file. The setting's value names the backend. A path names a markdown file, and `confluence:` a Confluence Cloud page; the goals file may also be a Jira epic's description, which `goals_store` picks."""
|
||||
import dataclasses
|
||||
import pathlib
|
||||
import typing
|
||||
|
||||
from failure import Failure
|
||||
from git_cli.git_repo import file_at, git, Git
|
||||
from project_config.settings import ProjectConfig, TOUCH_PREDICTIONS
|
||||
from project_config.settings import ProjectConfig, RECORDS, TOUCH_PREDICTIONS
|
||||
from text_files.file_writes import replace_file
|
||||
|
||||
# The settings in a project's config that each name a record.
|
||||
RECORDS = ("decisions", "score-anchors", "comprehension-history", "reading-cost", "changelog")
|
||||
|
||||
|
||||
class RecordStore(typing.Protocol):
|
||||
"""One record, as text. record_store.contract holds every backend to the same behaviour."""
|
||||
@@ -61,11 +58,17 @@ class FileStore:
|
||||
return Failure(f"cannot write {self.path}: {unwritten.reason}") if unwritten else None
|
||||
|
||||
|
||||
def store(config: ProjectConfig, record: str) -> RecordStore:
|
||||
"""The store config names for record, one of RECORDS."""
|
||||
def store(config: ProjectConfig, record: str, kept: pathlib.Path | None = None) -> RecordStore:
|
||||
"""The store config names for record, one of RECORDS. A record on a Confluence page keeps the version it read in the file kept, for a later process that writes it; None keeps it only in memory."""
|
||||
if record not in RECORDS:
|
||||
raise ValueError(f"{record} is not a record; the records are {', '.join(RECORDS)}")
|
||||
return FileStore(config.paths[record], config.tracked(record))
|
||||
if record not in config.pages:
|
||||
return FileStore(config.paths[record], config.tracked(record))
|
||||
# Imported here, as in goals_store.
|
||||
from record_store.confluence_page import ConfluencePage
|
||||
# load refuses a config that names a page and no env-file.
|
||||
assert config.env_file is not None
|
||||
return ConfluencePage(config.pages[record], config.env_file, kept)
|
||||
|
||||
|
||||
def touch_predictions_store(config: ProjectConfig) -> RecordStore | None:
|
||||
|
||||
@@ -0,0 +1,134 @@
|
||||
import base64
|
||||
import json
|
||||
import pathlib
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from failure import Failure
|
||||
from project_config.settings import Page
|
||||
from record_store.confluence_page import ConfluencePage
|
||||
from record_store.contract import RecordStoreContract
|
||||
from rest_client.json_request import ErrorAnswer
|
||||
|
||||
PAGE = Page("https://acme.atlassian.net", "2293761", "confluence:https://acme.atlassian.net/wiki/spaces/ENG/pages/2293761")
|
||||
URL = "https://acme.atlassian.net/wiki/api/v2/pages/2293761"
|
||||
AUTHORIZATION = "Basic " + base64.b64encode(b"me@example.com:s3cret").decode()
|
||||
|
||||
|
||||
class FakeConfluence:
|
||||
"""One page as Confluence Cloud's REST API version 2 serves it, refusing with 409 a write whose version isn't the current one plus one."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.title = "Decisions"
|
||||
self.version = 1
|
||||
self.value = ""
|
||||
self.calls: list[tuple[str, str, str, object]] = []
|
||||
|
||||
def http(self, method: str, url: str, authorization: str, body: object) -> object:
|
||||
self.calls.append((method, url, authorization, body))
|
||||
if method == "GET":
|
||||
return {"id": PAGE.page_id, "title": self.title, "version": {"number": self.version}, "body": {"atlas_doc_format": {"representation": "atlas_doc_format", "value": self.value}}}
|
||||
assert isinstance(body, dict)
|
||||
if body["version"]["number"] != self.version + 1:
|
||||
return ErrorAnswer(f"PUT /wiki/api/v2/pages/{PAGE.page_id} answered 409: Version must be incremented on update. Current version is: {self.version}", 409)
|
||||
self.title, self.version, self.value = body["title"], body["version"]["number"], body["body"]["value"]
|
||||
return {"id": PAGE.page_id, "version": {"number": self.version}}
|
||||
|
||||
def teammate_saves(self, text: str) -> None:
|
||||
self.version += 1
|
||||
self.value = json.dumps(to_adf(text))
|
||||
|
||||
|
||||
def to_adf(text: str) -> dict[str, object]:
|
||||
return {"type": "doc", "version": 1, "content": [{"type": "paragraph", "content": [{"type": "text", "text": text}]}]}
|
||||
|
||||
|
||||
def to_markdown(documents: list[dict[str, object]]) -> list[str]:
|
||||
return [document["content"][0]["content"][0]["text"] for document in documents] # type: ignore[index]
|
||||
|
||||
|
||||
class ConfluenceCase(unittest.TestCase):
|
||||
def setUp(self) -> None:
|
||||
folder = pathlib.Path(self.enterContext(tempfile.TemporaryDirectory()))
|
||||
self.env = folder / "acme.env"
|
||||
self.env.write_text("ATLASSIAN_EMAIL=me@example.com\nATLASSIAN_API_TOKEN=s3cret\n")
|
||||
self.env.chmod(0o600)
|
||||
self.kept = folder / "state" / "decisions.version"
|
||||
self.confluence = FakeConfluence()
|
||||
|
||||
def new_store(self, kept: pathlib.Path | None = None) -> ConfluencePage:
|
||||
return ConfluencePage(PAGE, self.env, kept, self.confluence.http, to_markdown, to_adf)
|
||||
|
||||
|
||||
class ConfluencePageContract(ConfluenceCase, RecordStoreContract):
|
||||
pass
|
||||
|
||||
|
||||
class ConfluencePageTest(ConfluenceCase):
|
||||
def test_reads_the_pages_document_as_markdown(self) -> None:
|
||||
self.confluence.teammate_saves("# Decisions\n")
|
||||
self.assertEqual(self.new_store().read(), "# Decisions\n")
|
||||
self.assertEqual(self.confluence.calls, [("GET", f"{URL}?body-format=atlas_doc_format", AUTHORIZATION, None)])
|
||||
|
||||
def test_writes_markdown_as_the_version_it_read_plus_one(self) -> None:
|
||||
self.confluence.version = 7
|
||||
store = self.new_store()
|
||||
store.read()
|
||||
self.assertIsNone(store.write("- a decision\n"))
|
||||
self.assertEqual(self.confluence.calls[-1], ("PUT", URL, AUTHORIZATION, {"id": PAGE.page_id, "status": "current", "title": "Decisions", "body": {"representation": "atlas_doc_format", "value": json.dumps(to_adf("- a decision\n"))}, "version": {"number": 8}}))
|
||||
|
||||
def test_refuses_to_overwrite_a_teammates_save_since_its_read_and_says_to_ask_the_human(self) -> None:
|
||||
store = self.new_store()
|
||||
store.read()
|
||||
self.confluence.teammate_saves("their edit\n")
|
||||
written = store.write("my edit\n")
|
||||
assert isinstance(written, Failure), written
|
||||
self.assertIn("a teammate saved", written.reason)
|
||||
self.assertIn("ask the human", written.reason)
|
||||
self.assertIn(PAGE.spelling, written.reason)
|
||||
self.assertEqual(self.new_store().read(), "their edit\n")
|
||||
|
||||
def test_keeps_the_version_it_read_in_its_file_for_a_later_process(self) -> None:
|
||||
self.new_store(self.kept).read()
|
||||
self.confluence.teammate_saves("their edit\n")
|
||||
written = self.new_store(self.kept).write("my edit\n")
|
||||
assert isinstance(written, Failure), written
|
||||
self.assertIn("a teammate saved", written.reason)
|
||||
|
||||
def test_a_later_process_writes_with_the_version_an_earlier_one_read_or_wrote(self) -> None:
|
||||
self.new_store(self.kept).read()
|
||||
self.assertIsNone(self.new_store(self.kept).write("first\n"))
|
||||
self.assertIsNone(self.new_store(self.kept).write("second\n"))
|
||||
self.assertEqual(self.new_store().read(), "second\n")
|
||||
|
||||
def test_a_write_with_no_read_replaces_the_page_as_it_stands(self) -> None:
|
||||
self.confluence.teammate_saves("earlier\n")
|
||||
self.assertIsNone(self.new_store().write("replaced\n"))
|
||||
self.assertEqual(self.confluence.calls[0], ("GET", URL, AUTHORIZATION, None))
|
||||
self.assertEqual(self.new_store().read(), "replaced\n")
|
||||
|
||||
def test_fails_on_an_answer_not_shaped_as_a_page(self) -> None:
|
||||
for answer in ({}, {"title": "Decisions", "version": {}, "body": {}}, ["not", "a", "page"]):
|
||||
with self.subTest(answer):
|
||||
store = ConfluencePage(PAGE, self.env, None, lambda *_: answer, to_markdown, to_adf)
|
||||
read = store.read()
|
||||
assert isinstance(read, Failure), read
|
||||
self.assertIn("not in the shape Confluence Cloud's REST API version 2 documents", read.reason)
|
||||
|
||||
def test_fails_naming_the_page_when_confluence_answers_an_error(self) -> None:
|
||||
store = ConfluencePage(PAGE, self.env, None, lambda *_: ErrorAnswer("GET /wiki/api/v2/pages/2293761 answered 404: Not Found", 404), to_markdown, to_adf)
|
||||
self.assertEqual(store.read(), Failure(f"cannot read {PAGE.spelling}: GET /wiki/api/v2/pages/2293761 answered 404: Not Found"))
|
||||
|
||||
def test_fails_without_credentials_before_any_request(self) -> None:
|
||||
self.env.unlink()
|
||||
read = self.new_store().read()
|
||||
assert isinstance(read, Failure), read
|
||||
self.assertIn("does not exist", read.reason)
|
||||
self.assertEqual(self.confluence.calls, [])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -6,7 +6,8 @@ import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from project_config.settings import Epic, ProjectConfig
|
||||
from record_store.confluence_page import ConfluencePage
|
||||
from project_config.settings import Epic, Page, ProjectConfig
|
||||
from record_store.jira_description import EpicDescription
|
||||
from failure import Failure
|
||||
from record_store.fakes import MemoryStore
|
||||
@@ -171,6 +172,12 @@ class Store(unittest.TestCase):
|
||||
stores.store(self.config(pathlib.Path("/code/acme"), pathlib.Path("/home/me/.claude-projects/acme")), "plan")
|
||||
self.assertEqual(str(refused.exception), "plan is not a record; the records are decisions, score-anchors, comprehension-history, reading-cost, changelog")
|
||||
|
||||
def test_a_record_on_a_confluence_page_is_that_page_keeping_its_version_where_asked(self):
|
||||
page = Page("https://acme.atlassian.net", "2293761", "confluence:https://acme.atlassian.net/wiki/spaces/ENG/pages/2293761")
|
||||
config = ProjectConfig("acme", pathlib.Path("/home/me/.claude-projects/acme"), pathlib.Path("/code/acme"), {}, pathlib.Path("/home/me/acme.env"), pages={"decisions": page})
|
||||
kept = pathlib.Path("/home/me/decisions.version")
|
||||
self.assertEqual(stores.store(config, "decisions", kept), ConfluencePage(page, pathlib.Path("/home/me/acme.env"), kept))
|
||||
|
||||
|
||||
class GoalsStore(unittest.TestCase):
|
||||
def test_goals_kept_as_a_file_are_that_file(self):
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
"""Sends one request to a REST API that speaks JSON, with a credential that no redirect may carry elsewhere."""
|
||||
import dataclasses
|
||||
import http.client
|
||||
import json
|
||||
import typing
|
||||
@@ -12,6 +13,12 @@ from failure import Failure
|
||||
MessageOf = typing.Callable[[object], str]
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class ErrorAnswer(Failure):
|
||||
"""The API answered an HTTP error, whose code is status, such as 409 for a conflict."""
|
||||
status: int
|
||||
|
||||
|
||||
class NoRedirect(urllib.request.HTTPRedirectHandler):
|
||||
"""Refuses every redirect, which a REST API doesn't send: urllib would resend the credential to the new location, even one off https."""
|
||||
|
||||
@@ -35,7 +42,7 @@ def http_json(method: str, url: str, authorization: str, body: object, seconds:
|
||||
raw = response.read()
|
||||
except urllib.error.HTTPError as failure:
|
||||
with failure:
|
||||
return Failure(f"{request_name} answered {failure.code}: {error_message(failure, message_of) or failure.reason}")
|
||||
return ErrorAnswer(f"{request_name} answered {failure.code}: {error_message(failure, message_of) or failure.reason}", failure.code)
|
||||
except http.client.HTTPException as failure:
|
||||
return Failure(f"{request_name} got a broken answer: {failure!r}")
|
||||
except (OSError, ValueError) as failure:
|
||||
|
||||
@@ -8,6 +8,7 @@ import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from rest_client.json_request import ErrorAnswer
|
||||
from failure import Failure
|
||||
from rest_client import json_request
|
||||
|
||||
@@ -74,11 +75,11 @@ class HttpJson(unittest.TestCase):
|
||||
|
||||
def test_names_the_request_the_status_and_the_apis_message_on_an_error(self):
|
||||
base = self.serve((401, b'{"message": "Invalid or expired session, please login again."}'))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "bad", None), Failure("GET /api/v4/users/me answered 401: Invalid or expired session, please login again."))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "bad", None), ErrorAnswer("GET /api/v4/users/me answered 401: Invalid or expired session, please login again.", 401))
|
||||
|
||||
def test_follows_no_redirect_so_the_token_goes_only_to_the_server_named(self):
|
||||
base = self.serve((302, b"{}"))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), Failure("GET /api/v4/users/me answered 302: Found"))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), ErrorAnswer("GET /api/v4/users/me answered 302: Found", 302))
|
||||
self.assertEqual(len(self.server.got), 1) # type: ignore[attr-defined]
|
||||
|
||||
def test_sends_no_body_with_a_get(self):
|
||||
@@ -96,7 +97,7 @@ class HttpJson(unittest.TestCase):
|
||||
|
||||
def test_names_the_status_of_an_error_whose_body_is_cut_short(self):
|
||||
base = self.serve((None, b"HTTP/1.1 500 Internal Server Error\r\nContent-Length: 100\r\n\r\n{}"))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), Failure("GET /api/v4/users/me answered 500: Internal Server Error"))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), ErrorAnswer("GET /api/v4/users/me answered 500: Internal Server Error", 500))
|
||||
|
||||
def test_gives_up_on_a_server_that_never_answers_after_the_timeout(self):
|
||||
silent = socket.socket()
|
||||
@@ -126,7 +127,7 @@ class HttpJson(unittest.TestCase):
|
||||
|
||||
def test_an_error_whose_body_is_not_json_names_the_status_alone(self):
|
||||
base = self.serve((403, b"<html>"))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), Failure("GET /api/v4/users/me answered 403: Forbidden"))
|
||||
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), ErrorAnswer("GET /api/v4/users/me answered 403: Forbidden", 403))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -23,6 +23,7 @@ Each project principle states one rule that the decisions below apply; their ent
|
||||
- project config: a tool that reads a file's commits says where it does not support that file, and the work goes on
|
||||
- project config: `language` names the prose's language by its English name, and `commit-title`, `pull-request-title` and `branch` are brace templates over `{id}` and `{summary}`
|
||||
- project config: `plan` may name a Jira Cloud epic as `jira:` and its address, the plan is its open child issues in backlog order, and an issue's number is the item's ID
|
||||
- project config: a record may name a Confluence Cloud page as `confluence:` and its address, the loop reads and writes it as markdown, and a write never overwrites a save made since the loop's read
|
||||
- project config: `tooling-on-host = true` lets a project with no container setup run its language runtime, package manager, tests and task runner on the host
|
||||
- review: a release review fixes its findings in the release it reviews, and files under that release only a finding that needs a human answer, adds a feature or outlasts its five rounds
|
||||
- review: a reviewer or comprehension seat that rules the work below standard may ask to rerun once, one rung up, in the same round; the ruling that stands is an escalation trigger for the worker unless the fix changes only prose, and never for the judge
|
||||
@@ -305,6 +306,15 @@ Messages keep each file's usual name, such as `todo.md`, as its label, since the
|
||||
- **The loop files an item as a Task under the epic, and marks it as its own** (lilleman's calls of 2026-11-12). `"Filed by": "loop"` in the `plan-item` property tells such an issue from one a person filed, whose summary and description the loop never edits. Task is an issue type every Jira Software project template has; a project without it refuses the issue, saying so. The issue takes the project's Fix Version named as the release, with a leading v or without, and the store refuses an item whose release the project has no Fix Version for, before it files anything. A security finding also gets the label `security`, and its text never holds a secret's value. Jira ranks the new issue last, and no bar or goals check applies, until todo.md's item 384 says where a plan in Jira states its formula. Jira takes a blocker's link only after the issue exists, so the store first checks that each blocker is an open child. A link Jira still refuses leaves the issue filed: the write counts as landed, with a note naming the link to make by hand. A failed create says the issue may exist all the same, since a lost answer doesn't tell.
|
||||
- **The store reads and files, and doesn't edit or finish an issue** until todo.md's items 382 and 383. `rank_todo.py` refuses to rank a plan in Jira, and its `--check` passes, since Jira's backlog ranks it; rule-hook's rank check skips it. Each read first asks Jira for the epic itself, since a search under an epic the account cannot see answers no issues, as a finished plan does.
|
||||
|
||||
## project config: a record may name a Confluence Cloud page as `confluence:` and its address, the loop reads and writes it as markdown, and a write never overwrites a save made since the loop's read
|
||||
|
||||
2026-11-15, larv-review, on lilleman's calls of 2026-11-12. Serves goal 1.6: a client's team keeps its records in its own wiki. Valid while one record fits one page.
|
||||
|
||||
- **A bench of readers picked the spelling.** Three fresh readers, seated as the person who writes a client's `config.toml`, each picked `decisions = "confluence:https://<site>/wiki/spaces/<space>/pages/<page ID>"`, pasted from the browser with or without the title at its end, over the bare address, a page ID beside a `confluence-site` key, and a table. Each named the match with `jira:`. Any of the five records may name a page; the goals file, the plan, the working rules and the principles may not.
|
||||
- **A write sends the version number the store read, plus one, and Confluence refuses it with 409 where someone saved the page since.** The store then fails, saying to ask the human, and doesn't write the page; the loop never overwrites a teammate's edit on its own (lilleman, 2026-11-12). A write with no read before it replaces the page as it stands, as the record contract asks.
|
||||
- **`project-record` keeps the version `open` read in a file beside its copy**, `~/.local/state/project-record/<key>/<record>.version`, since `save` runs in a later process. The store keeps the version itself, so `write` still takes only the text. Every other tool reads and writes a record in one process, and its store keeps the version in memory, so a read by another tool, such as larv-review's, never moves the version an edit in `project-record` rests on.
|
||||
- **The page holds ADF, which adf-codec converts both ways**, so a teammate reads the record as Confluence renders it. Markdown adf-codec cannot express fails the write, naming adf-codec's error.
|
||||
|
||||
## project config: `tooling-on-host = true` lets a project with no container setup run its language runtime, package manager, tests and task runner on the host
|
||||
|
||||
2026-11-12, lilleman, through todo item 358. Serves goal 1.6: a legacy product may have no container setup, and the loop works in it without its owners adding one. `CLAUDE.md`'s container rule and the stability reviewer follow the setting. rule-hook checks only how a container starts, its memory limits and its image's pin, never where a runtime runs, so it needs no change. A decision may still put one tool on the host where the project has containers, as this repo's `bin/` decision does. Readers seated as the person who writes the config picked the key, 2 of 3. Valid while the loop runs on the machine that holds the checkout.
|
||||
|
||||
@@ -2185,3 +2185,16 @@ Read most (opens and searches):
|
||||
- `bin/release_plan/release_standing.py` 1
|
||||
- `docs/decisions.md` 1
|
||||
- `docs/score-anchors.md` 1
|
||||
|
||||
## Reading cost, chunk 6cc45aabfc70, finished 2026-11-15T10:19:26Z
|
||||
|
||||
81857 new input tokens before the first commit.
|
||||
|
||||
Read most (opens and searches):
|
||||
|
||||
- `docs/score-anchors.md` 3
|
||||
- `bin/plan_store/jira_epic.py` 2
|
||||
- `bin/plan_store/stores.py` 2
|
||||
- `rules/todo-items.md` 2
|
||||
- `bin/adf_codec/convert.py` 1
|
||||
- `bin/plan_store/contract.py` 1
|
||||
|
||||
Reference in New Issue
Block a user