Merge remote-tracking branch 'origin/main' into item-409
CI / tests (pull_request) Successful in 5m26s
CI / tests (pull_request) Successful in 5m26s
This commit is contained in:
@@ -2,6 +2,8 @@
|
||||
|
||||
## Unreleased
|
||||
|
||||
- do-epic's epic backends read each issue's scores, its blockers and whether the loop filed it, in the Jira backend and the in-memory one; the Jira backend marks each issue it files as the loop's. Nothing calls it yet.
|
||||
- The technical principles now forbid a test that decides at run time whether to check anything, by a conditional skip, early return or catch around its assertions, and stability-reviewer flags one.
|
||||
- do-epic's scorer orders an epic's items by score, then by Blocked by: an item's Moves names a goal as `epic 1.1`, `code health` or `repo 2`, and the epic's achieve goals outweigh the achieve goals of every repo. Nothing calls it yet.
|
||||
- `todo-item add` and `todo-item edit --detail` refuse a detail whose `Touches:` list touch-predictions cannot read, and `rank_todo.py --check` fails on each item holding one, so rule-hook refuses a commit of such a plan: after updating, run `~/.claude/bin/rank_todo.py --check` in each project and fix each list it names.
|
||||
- loop-claude hands each worker's claude a Bash output ceiling of 6,000 characters that saves a longer result to a file, rule-hook refuses a Read of a session transcript under ~/.claude/projects, and review-replay takes --bash-ceiling and --read-limit to test such a limit against archived review rounds.
|
||||
|
||||
@@ -240,9 +240,9 @@ Install puts only `loop-claude` on `PATH`; call the others by their path, such a
|
||||
|
||||
## Test
|
||||
|
||||
Test on the host with `bin/run-tests`, which runs pytest through `uvx`, pinned in `bin/run_tests/main.py`. It prints each failing test with its error and pytest's summary line, and saves the whole output to a file whose path it prints. It passes on any test paths or pytest options it is given, such as `bin/run-tests bin/chunk_pr -x`. It needs `uv` on `PATH`, which fetches pytest, pytest-xdist and mypy. pytest-xdist runs the tests in one worker per CPU of a heavy slot (`docs/decisions.md` → `bin/: the tools support only the latest stable Python, …`). `python3 -m unittest discover -s bin -p 'test_*.py'` runs the same tests one at a time. Test the bench's scripts with `python3 -m unittest discover -s workflow-bench -p 'test_*.py'`.
|
||||
Test on the host with `bin/run-tests`, which runs pytest through `uvx`, pinned in `bin/run_tests/main.py`. It prints each failing test with its error and pytest's summary line, and saves the whole output to a file whose path it prints. It passes on any test paths or pytest options it is given, such as `bin/run-tests bin/chunk_pr -x`. It needs `uv` on `PATH`, which fetches pytest, pytest-xdist and mypy, a Docker daemon, Linux, and a user other than root; a test that lacks one fails, naming it. pytest-xdist runs the tests in one worker per CPU of a heavy slot (`docs/decisions.md` → `bin/: the tools support only the latest stable Python, …`). `python3 -m unittest discover -s bin -p 'test_*.py'` runs the same tests one at a time, with the same needs. Test the bench's scripts with `python3 -m unittest discover -s workflow-bench -p 'test_*.py'`.
|
||||
|
||||
CI runs `ci.sh` on every pull request, and `main` doesn't merge anything until it passes. The script runs the same tests on the committed HEAD in a pinned Python container; run it under `run-heavy` to reproduce a CI failure, with Docker on `PATH`.
|
||||
CI runs `ci.sh` on every pull request, and `main` doesn't merge anything until it passes. The script runs the same tests on the committed HEAD in a pinned Python container. Run it under `run-heavy` to reproduce a CI failure, with Docker on `PATH` and its socket at `/var/run/docker.sock`, which the container shares.
|
||||
|
||||
To mutation-test the lines a branch changes, run `~/.claude/bin/run-heavy ~/.claude/bin/mutate-changes --prefix 'uvx --python "$(command -v python3)" --with pytest==9.2.0 --from "mutmut>=3,<4"'` in its checkout.
|
||||
|
||||
|
||||
@@ -125,6 +125,7 @@ Every PR gets at least this sweep.
|
||||
- Was a test deleted while the behaviour it pinned remains? Flag it; restore the test.
|
||||
- Were tests and implementation changed together in a way that could mask a regression — e.g. an assertion weakened to make a test pass? Flag it; these should be separate changes.
|
||||
- Does each test earn its keep, as the technical principles' test bullet says? Look at where its expected values come from, what it asserts, what it mocks, what wording it pins, whether another test already pins the behaviour, and whether it sleeps or reads the wall clock.
|
||||
- Does a test decide at run time whether to check anything, by a conditional skip, early return or catch around its assertions, as the technical principles' test bullet forbids? Flag it.
|
||||
- Are there untestable side effects that should be refactored?
|
||||
|
||||
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import contextlib
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
|
||||
import pytest
|
||||
@@ -296,10 +295,10 @@ def test_container_run_passes_an_image_failure_through(tmp_path):
|
||||
assert convert.container_run("to-adf", "text", scripted(down), shim_dir(tmp_path)) == down
|
||||
|
||||
|
||||
@pytest.mark.skipif(shutil.which("docker") is None or subprocess.run(["docker", "info"], capture_output=True, timeout=20).returncode != 0, reason="needs a docker daemon")
|
||||
def test_round_trip_through_the_real_container():
|
||||
doc = convert.markdown_to_adf("# Title\n\nSome **bold** text.\n")
|
||||
assert isinstance(doc, dict) and doc["type"] == "doc" and doc["content"][0]["type"] == "heading"
|
||||
assert isinstance(doc, dict), doc
|
||||
assert doc["type"] == "doc" and doc["content"][0]["type"] == "heading"
|
||||
markdown = convert.adf_to_markdown(doc)
|
||||
assert isinstance(markdown, str) and markdown.startswith("# Title") and "**bold**" in markdown
|
||||
refused = convert.adf_to_markdown({"type": "nope"})
|
||||
@@ -324,10 +323,9 @@ JIRA_DESCRIPTION = {
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.skipif(shutil.which("docker") is None or subprocess.run(["docker", "info"], capture_output=True, timeout=20).returncode != 0, reason="needs a docker daemon")
|
||||
def test_the_lossless_pair_gives_back_a_jira_description_identical_and_the_portable_pair_does_not():
|
||||
markdown = convert.adf_to_markdown_lossless(JIRA_DESCRIPTION)
|
||||
assert isinstance(markdown, str)
|
||||
assert isinstance(markdown, str), markdown
|
||||
assert convert.markdown_to_adf_lossless(markdown) == JIRA_DESCRIPTION
|
||||
assert convert.adfs_to_markdown_lossless([JIRA_DESCRIPTION, JIRA_DESCRIPTION]) == [markdown, markdown]
|
||||
portable = convert.markdown_to_adf(convert.adf_to_markdown(JIRA_DESCRIPTION))
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
"""What every backend of an epic's plan must hold, as tests. A backend's test case inherits EpicStoreContract and unittest.TestCase, and builds an epic with no issues in new_store. Its comments_on reads an issue's comments, and its assign and close change an issue as a person would in the tracker."""
|
||||
"""What every backend of an epic's plan must hold, as tests. A backend's test case inherits EpicStoreContract and unittest.TestCase, and builds an epic with no issues in new_store. Its comments_on reads an issue's comments. Its assign, close, person_files, score and block change the tracker as a person or the plan store would."""
|
||||
import re
|
||||
import typing
|
||||
|
||||
@@ -26,6 +26,18 @@ class EpicStoreContract:
|
||||
"""The text of each comment on the issue named key, in the order posted, as markdown."""
|
||||
raise NotImplementedError
|
||||
|
||||
def person_files(self, store: EpicStore, summary: str) -> str:
|
||||
"""Files a child issue of the epic as a person does in the tracker, not through the store, and answers its key."""
|
||||
raise NotImplementedError
|
||||
|
||||
def score(self, store: EpicStore, key: str, scores: dict[str, object]) -> None:
|
||||
"""Sets the scores of the issue named key as `plan_store` writes them: each column's name with its value, a whole number for a score and text for Moves and Exempt, such as {"L": 2, "Moves": "1 by 5"}."""
|
||||
raise NotImplementedError
|
||||
|
||||
def block(self, store: EpicStore, key: str, blocker: str) -> None:
|
||||
"""Makes the issue named key blocked by the issue named blocker, as a person would link them in the tracker."""
|
||||
raise NotImplementedError
|
||||
|
||||
def filed(self, store: EpicStore, parent: str, summary: str, detail: str = "", labels: tuple[str, ...] = ()) -> str:
|
||||
key = store.file(parent, summary, detail, labels)
|
||||
assert isinstance(key, str), key
|
||||
@@ -42,7 +54,7 @@ class EpicStoreContract:
|
||||
def test_reads_back_a_child_issue_it_filed(self) -> None:
|
||||
store = self.new_store()
|
||||
key = self.filed(store, store.epic_key, "Count the runs.", "Why it counts.\n\nA second paragraph.", ("security", "api"))
|
||||
self.assertEqual(self.issues(store), [EpicIssue(key, "Count the runs.", "Why it counts.\n\nA second paragraph.", ("api", "security"), None, "To Do", False, store.epic_key)])
|
||||
self.assertEqual(self.issues(store), [EpicIssue(key, "Count the runs.", "Why it counts.\n\nA second paragraph.", ("api", "security"), None, "To Do", False, store.epic_key, by_loop=True)])
|
||||
|
||||
def test_reads_back_a_sub_task_it_filed_after_its_parent(self) -> None:
|
||||
store = self.new_store()
|
||||
@@ -127,3 +139,34 @@ class EpicStoreContract:
|
||||
self.assertEqual(store.comment(child, " \n"), Failure("the comment must hold some text"))
|
||||
self.assertIsInstance(store.comment("ZZZ-1", "Hello."), Failure)
|
||||
self.assertEqual([self.comments_on(store, key) for key in (child, task)], [[], []])
|
||||
|
||||
def test_reads_an_issue_without_scores_or_blockers_as_one_with_none(self) -> None:
|
||||
store = self.new_store()
|
||||
key = self.filed(store, store.epic_key, "Count the runs.")
|
||||
[issue] = self.issues(store)
|
||||
self.assertEqual((issue.key, issue.scores, issue.moves, issue.exempt, issue.blockers), (key, {}, (), "", ()))
|
||||
|
||||
def test_reads_the_scores_a_person_or_the_plan_store_set(self) -> None:
|
||||
store = self.new_store()
|
||||
key = self.filed(store, store.epic_key, "Count the runs.")
|
||||
self.score(store, key, {"L": 2, "E": 3, "I": 4, "S": 3, "Moves": "1 by 5", "Exempt": "security"})
|
||||
[issue] = self.issues(store)
|
||||
self.assertEqual((issue.scores, issue.moves, issue.exempt), ({"L": 2, "E": 3, "I": 4, "S": 3}, (("1", 5),), "security"))
|
||||
|
||||
def test_reads_each_blocker_of_an_issue_and_none_for_a_blocker_of_another(self) -> None:
|
||||
store = self.new_store()
|
||||
first, second, third = (self.filed(store, store.epic_key, f"Item {n}.") for n in range(3))
|
||||
self.block(store, third, first)
|
||||
self.block(store, third, second)
|
||||
read = {issue.key: issue for issue in self.issues(store)}
|
||||
self.assertEqual([read[key].blockers for key in (first, second, third)], [(), (), (first, second)])
|
||||
|
||||
def test_reads_whether_the_loop_filed_an_issue(self) -> None:
|
||||
store = self.new_store()
|
||||
ours = self.filed(store, store.epic_key, "Count the runs.")
|
||||
theirs = self.person_files(store, "A person's issue.")
|
||||
# The plan store scores an issue a person filed without making it the loop's.
|
||||
self.score(store, theirs, {"L": 2, "E": 3, "I": 4, "S": 3, "Moves": "1 by 5"})
|
||||
task = self.filed(store, ours, "Count them in the api.")
|
||||
read = {issue.key: issue for issue in self.issues(store)}
|
||||
self.assertEqual([read[key].by_loop for key in (ours, theirs, task)], [True, False, True])
|
||||
|
||||
@@ -26,7 +26,7 @@ class MemoryEpic:
|
||||
if parent != self.epic_key and parent not in {issue.key for issue in self.issues if issue.parent == self.epic_key}:
|
||||
return no_parent(self.epic_key, parent)
|
||||
key = f"{self.epic_key.rpartition('-')[0]}-{len(self.issues) + 100}"
|
||||
self.issues.append(EpicIssue(key, summary, detail.strip(), tuple(sorted(labels)), None, "To Do", False, parent))
|
||||
self.issues.append(EpicIssue(key, summary, detail.strip(), tuple(sorted(labels)), None, "To Do", False, parent, by_loop=True))
|
||||
return key
|
||||
|
||||
def add_label(self, key: str, label: str) -> None | Failure:
|
||||
|
||||
@@ -5,12 +5,12 @@ import typing
|
||||
|
||||
from adf_codec.convert import adfs_to_markdown, markdown_to_adf, Refused
|
||||
from atlassian.client import basic_auth, Http, jira_json, ToAdf, ToMarkdown
|
||||
from plan_store.jira_epic import blocked_by_links, FILED_BY, ISSUE_KEY, ISSUE_TYPE, project_of, PROPERTY, scores, searched
|
||||
from project_config.settings import Epic
|
||||
from do_epic.backend.protocol import EpicIssue, no_child, no_parent, no_words, unfit, unfit_label
|
||||
from failure import Failure
|
||||
from plan_store.jira_epic import ISSUE_KEY, ISSUE_TYPE, project_of, searched
|
||||
|
||||
FIELDS = ["summary", "description", "labels", "assignee", "status", "parent"]
|
||||
FIELDS = ["summary", "description", "labels", "assignee", "status", "parent", "issuelinks"]
|
||||
# How many child issues one search for sub-tasks names, which keeps its JQL well inside the length Jira takes.
|
||||
PARENTS_PER_SEARCH = 50
|
||||
PERHAPS_FILED = "unless Jira refused the request, the issue may exist: look under {parent} before filing it again"
|
||||
@@ -60,6 +60,8 @@ class JiraEpic:
|
||||
if refused := unfit(summary, labels) or self.not_a_parent(parent, authorization):
|
||||
return refused
|
||||
fields: dict[str, typing.Any] = {"project": {"key": project_of(parent)}, "parent": {"key": parent}, "summary": summary, "labels": list(labels)}
|
||||
# Marks the issue as the loop's, as plan_store marks the items it files.
|
||||
properties = [{"key": PROPERTY, "value": {FILED_BY[0]: FILED_BY[1]}}]
|
||||
kind = {"name": ISSUE_TYPE} if parent == self.epic_key else self.sub_task_type(project_of(parent), authorization)
|
||||
if isinstance(kind, Failure):
|
||||
return kind
|
||||
@@ -68,7 +70,7 @@ class JiraEpic:
|
||||
if isinstance(description, Failure):
|
||||
return Failure(f"cannot convert the detail to a Jira description: {description.reason}")
|
||||
fields["description"] = description
|
||||
created = self.http("POST", f"{self.epic.site}/rest/api/3/issue", authorization, {"fields": fields | {"issuetype": kind}})
|
||||
created = self.http("POST", f"{self.epic.site}/rest/api/3/issue", authorization, {"fields": fields | {"issuetype": kind}, "properties": properties})
|
||||
if isinstance(created, Failure):
|
||||
return Failure(f"cannot file the issue under {parent}: {created.reason}; {PERHAPS_FILED.format(parent=parent)}")
|
||||
key = created.get("key") if isinstance(created, dict) else None
|
||||
@@ -147,7 +149,7 @@ class JiraEpic:
|
||||
def searched(self, what: str, parents: tuple[str, ...], authorization: str) -> list[Found] | Failure:
|
||||
"""The issues whose parent is one of parents, in rank order."""
|
||||
named = ", ".join(f'"{key}"' for key in parents)
|
||||
answered = searched(self.epic.site, what, f"parent in ({named}) ORDER BY Rank ASC", {"fields": FIELDS}, authorization, self.http)
|
||||
answered = searched(self.epic.site, what, f"parent in ({named}) ORDER BY Rank ASC", {"fields": FIELDS, "properties": [PROPERTY]}, authorization, self.http)
|
||||
if isinstance(answered, Failure):
|
||||
return answered
|
||||
found = [found_of(raw) for raw in answered]
|
||||
@@ -176,9 +178,16 @@ def found_of(raw: object) -> Found | Failure:
|
||||
summary, labels, assignee, status, parent, description = fields["summary"], fields["labels"], fields["assignee"], fields["status"], fields["parent"]["key"], fields["description"]
|
||||
name = assignee["displayName"] if assignee is not None else None
|
||||
state, done = status["name"], status["statusCategory"]["key"] == "done"
|
||||
blockers = tuple(link.blocker for link in blocked_by_links(fields))
|
||||
held = raw.get("properties", {}).get(PROPERTY, {})
|
||||
except (AttributeError, KeyError, TypeError) as failure:
|
||||
return Failure(f"{key} is not in the shape Jira Cloud's REST API version 3 documents: {failure!r}")
|
||||
texts = (summary, *labels, state, parent) if isinstance(labels, list) else ()
|
||||
if not texts or not all(isinstance(text, str) for text in texts) or not isinstance(name, str | None) or not ISSUE_KEY.fullmatch(parent) or not isinstance(description, dict | None):
|
||||
return Failure(f"{key} is not in the shape Jira Cloud's REST API version 3 documents: its summary, labels, assignee, status, parent or description holds another kind of value")
|
||||
return Found(EpicIssue(key, summary.strip(), "", tuple(sorted(labels)), name, state, done, parent), description)
|
||||
texts = (summary, *labels, state, parent, *blockers) if isinstance(labels, list) else ()
|
||||
if not texts or not all(isinstance(text, str) for text in texts) or not isinstance(name, str | None) or not all(ISSUE_KEY.fullmatch(each) for each in (parent, *blockers)) or not isinstance(description, dict | None):
|
||||
return Failure(f"{key} is not in the shape Jira Cloud's REST API version 3 documents: its summary, labels, assignee, status, parent, description or a linked issue's key holds another kind of value")
|
||||
if not isinstance(held, dict):
|
||||
return Failure(f"{key}'s issue property {PROPERTY} is not a JSON object")
|
||||
read = scores(key, held)
|
||||
if isinstance(read, Failure):
|
||||
return read
|
||||
return Found(EpicIssue(key, summary.strip(), "", tuple(sorted(labels)), name, state, done, parent, read.scores, read.moves, read.exempt, blockers, held.get(FILED_BY[0]) == FILED_BY[1]), description)
|
||||
|
||||
@@ -5,6 +5,7 @@ import dataclasses
|
||||
import re
|
||||
import typing
|
||||
|
||||
from plan.todo_table import Exempt, Moves
|
||||
from failure import Failure
|
||||
|
||||
# What a tracker accepts as a label: Jira refuses a label holding white space.
|
||||
@@ -28,6 +29,16 @@ class EpicIssue:
|
||||
done: bool
|
||||
# The epic's key for a child issue, the child's key for a sub-task.
|
||||
parent: str
|
||||
# The score of each column the issue has one for, such as {"L": 2}, as `plan_store` reads them from the issue's `plan-item` property. Empty where the issue has no scores.
|
||||
scores: dict[str, int] = dataclasses.field(default_factory=dict)
|
||||
# The goals the issue moves, and how far (the plan's Moves cell); empty where it names none.
|
||||
moves: Moves = ()
|
||||
# Why the issue is exempt from the plan's score bar, as the plan's Exempt cell names it; empty where it isn't.
|
||||
exempt: Exempt = ""
|
||||
# The key of each issue that blocks this one, in the tracker's order.
|
||||
blockers: tuple[str, ...] = ()
|
||||
# True where the loop filed the issue through EpicStore.file; False for an issue a person filed.
|
||||
by_loop: bool = False
|
||||
|
||||
|
||||
class EpicStore(typing.Protocol):
|
||||
@@ -41,7 +52,7 @@ class EpicStore(typing.Protocol):
|
||||
"""Each child issue, open or done, in the tracker's rank order, each followed by its sub-tasks in theirs."""
|
||||
|
||||
def file(self, parent: str, summary: str, detail: str, labels: tuple[str, ...]) -> str | Failure:
|
||||
"""Files an open issue under parent and answers its key: a child issue where parent is the epic, a sub-task where parent is one of its child issues. detail is markdown, and may be empty."""
|
||||
"""Files an open issue under parent, marked as filed by the loop, and answers its key: a child issue where parent is the epic, a sub-task where parent is one of its child issues. detail is markdown, and may be empty."""
|
||||
|
||||
def add_label(self, key: str, label: str) -> None | Failure:
|
||||
"""Adds label to the epic's child issue named key, leaving its other labels as they are; adding one it already has leaves the labels as they are. A sub-task, or an issue outside the epic, is refused."""
|
||||
|
||||
@@ -6,6 +6,7 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2]))
|
||||
|
||||
from do_epic.backend.contract import EpicStoreContract
|
||||
from failure import Failure
|
||||
from plan_store import jira_epic
|
||||
from do_epic.backend.fake import MemoryEpic
|
||||
|
||||
|
||||
@@ -22,6 +23,19 @@ class MemoryEpicContract(EpicStoreContract, unittest.TestCase):
|
||||
def close(self, store: MemoryEpic, key: str, status: str) -> None: # type: ignore[override]
|
||||
store.change(key, status=status, done=True)
|
||||
|
||||
def person_files(self, store: MemoryEpic, summary: str) -> str: # type: ignore[override]
|
||||
key = self.filed(store, store.epic_key, summary)
|
||||
store.change(key, by_loop=False)
|
||||
return key
|
||||
|
||||
def score(self, store: MemoryEpic, key: str, scores: dict[str, object]) -> None: # type: ignore[override]
|
||||
read = jira_epic.scores(key, scores)
|
||||
assert not isinstance(read, Failure), read
|
||||
store.change(key, scores=read.scores, moves=read.moves, exempt=read.exempt)
|
||||
|
||||
def block(self, store: MemoryEpic, key: str, blocker: str) -> None: # type: ignore[override]
|
||||
store.change(key, blockers=(*next(issue for issue in store.issues if issue.key == key).blockers, blocker))
|
||||
|
||||
|
||||
class Failing(unittest.TestCase):
|
||||
def test_every_read_filing_label_and_comment_fails_with_the_reason_given(self) -> None:
|
||||
|
||||
@@ -77,7 +77,7 @@ class FakeJira:
|
||||
if matched is None:
|
||||
return Failure("Jira answered 400: the JQL is not valid")
|
||||
parents = re.findall(r'"([A-Z]+-[0-9]+)"', matched[1])
|
||||
found = [{"key": issue["key"], "fields": {name: value for name, value in issue["fields"].items() if name in body.get("fields", [])}} for issue in self.issues if issue["fields"]["parent"]["key"] in parents] # type: ignore[index, attr-defined]
|
||||
found = [{"key": issue["key"], "fields": {name: value for name, value in issue["fields"].items() if name in body.get("fields", [])}, "properties": {name: value for name, value in issue.get("properties", {}).items() if name in body.get("properties", [])}} for issue in self.issues if issue["fields"]["parent"]["key"] in parents] # type: ignore[index, attr-defined]
|
||||
start = int(body.get("nextPageToken", 0))
|
||||
return {"issues": found[start:start + 2]} | ({"nextPageToken": str(start + 2)} if start + 2 < len(found) else {})
|
||||
|
||||
@@ -89,12 +89,21 @@ class FakeJira:
|
||||
if fields["project"] != {"key": "ABC"} or kind is None or fields["issuetype"] != kind:
|
||||
return Failure("Jira answered 400: the project, parent or issue type is not valid")
|
||||
key = f"ABC-{len(self.issues) + 100}"
|
||||
self.issues.append({"key": key, "fields": {"summary": fields["summary"], "description": fields.get("description"), "labels": fields["labels"], "assignee": None, "status": TO_DO, "parent": {"key": parent}}})
|
||||
self.issues.append({"key": key, "fields": {"summary": fields["summary"], "description": fields.get("description"), "labels": fields["labels"], "assignee": None, "status": TO_DO, "parent": {"key": parent}, "issuelinks": []}, "properties": {entry["key"]: entry["value"] for entry in body["properties"]}})
|
||||
return {"id": "1", "key": key}
|
||||
|
||||
def change(self, key: str, **fields: object) -> None:
|
||||
next(issue for issue in self.issues if issue["key"] == key)["fields"].update(fields) # type: ignore[union-attr]
|
||||
|
||||
def person_files(self, summary: str) -> str:
|
||||
"""Files a child issue as the Jira website does: with no issue property."""
|
||||
key = f"ABC-{len(self.issues) + 100}"
|
||||
self.issues.append({"key": key, "fields": {"summary": summary, "description": None, "labels": [], "assignee": None, "status": TO_DO, "parent": {"key": "ABC-12"}, "issuelinks": []}})
|
||||
return key
|
||||
|
||||
def set_property(self, key: str, value: dict[str, object]) -> None:
|
||||
next(issue for issue in self.issues if issue["key"] == key).setdefault("properties", {})["plan-item"] = value # type: ignore[attr-defined, union-attr]
|
||||
|
||||
|
||||
class Case(unittest.TestCase):
|
||||
def setUp(self) -> None:
|
||||
@@ -119,6 +128,17 @@ class JiraEpicContract(Case, EpicStoreContract):
|
||||
def close(self, store: JiraEpic, key: str, status: str) -> None: # type: ignore[override]
|
||||
self.jira.change(key, status={"name": status, "statusCategory": {"key": "done"}})
|
||||
|
||||
def person_files(self, store: JiraEpic, summary: str) -> str: # type: ignore[override]
|
||||
return self.jira.person_files(summary)
|
||||
|
||||
def score(self, store: JiraEpic, key: str, scores: dict[str, object]) -> None: # type: ignore[override]
|
||||
held = next(issue for issue in self.jira.issues if issue["key"] == key).get("properties", {}).get("plan-item", {}) # type: ignore[attr-defined, union-attr]
|
||||
self.jira.set_property(key, held | scores)
|
||||
|
||||
def block(self, store: JiraEpic, key: str, blocker: str) -> None: # type: ignore[override]
|
||||
links = next(issue for issue in self.jira.issues if issue["key"] == key)["fields"]["issuelinks"] # type: ignore[index]
|
||||
links.append({"id": str(len(links) + 1), "type": {"inward": "is blocked by", "outward": "blocks"}, "inwardIssue": {"key": blocker}})
|
||||
|
||||
|
||||
class Jira(Case):
|
||||
def test_reads_the_sub_tasks_of_more_children_than_one_search_names(self) -> None:
|
||||
@@ -154,16 +174,21 @@ class Jira(Case):
|
||||
self.assertEqual(len(self.jira.issues), 1)
|
||||
|
||||
def test_an_issue_in_another_shape_fails_the_read(self) -> None:
|
||||
valid = {"summary": "Count the runs.", "description": None, "labels": [], "assignee": None, "status": TO_DO, "parent": {"key": "ABC-12"}}
|
||||
valid = {"summary": "Count the runs.", "description": None, "labels": [], "assignee": None, "status": TO_DO, "parent": {"key": "ABC-12"}, "issuelinks": []}
|
||||
linked = {"id": "1", "type": {"inward": "is blocked by"}, "inwardIssue": {"key": "ABC-2"}}
|
||||
shape = "ABC-34 is not in the shape Jira Cloud's REST API version 3 documents"
|
||||
for raw, reason in (
|
||||
("ABC-34", "the search answered an issue without an issue key"),
|
||||
({"fields": valid}, "the search answered an issue without an issue key"),
|
||||
({"key": "abc-34", "fields": valid}, "the search answered an issue without an issue key"),
|
||||
({"key": "ABC-34", "fields": {"summary": "Count the runs.", "parent": {"key": "ABC-12"}}}, shape + ": KeyError('labels')"),
|
||||
*((({"key": "ABC-34", "fields": valid | changed}, shape + ": its summary, labels, assignee, status, parent or description holds another kind of value") for changed in (
|
||||
{"summary": 3}, {"labels": "api"}, {"labels": [3]}, {"assignee": {"displayName": 0}}, {"status": {"name": 0, "statusCategory": {"key": "new"}}}, {"parent": {"key": "ABC"}}, {"parent": {"key": 12}}, {"description": "text"},
|
||||
*((({"key": "ABC-34", "fields": valid | changed}, shape + ": its summary, labels, assignee, status, parent, description or a linked issue's key holds another kind of value") for changed in (
|
||||
{"summary": 3}, {"labels": "api"}, {"labels": [3]}, {"assignee": {"displayName": 0}}, {"status": {"name": 0, "statusCategory": {"key": "new"}}}, {"parent": {"key": "ABC"}}, {"parent": {"key": 12}}, {"description": "text"}, {"issuelinks": [linked | {"inwardIssue": {"key": 7}}]}, {"issuelinks": [linked | {"inwardIssue": {"key": "ABC-x"}}]},
|
||||
))),
|
||||
({"key": "ABC-34", "fields": {key: value for key, value in valid.items() if key != "issuelinks"}}, shape + ": KeyError('issuelinks')"),
|
||||
({"key": "ABC-34", "fields": valid, "properties": {"plan-item": "L 2"}}, "ABC-34's issue property plan-item is not a JSON object"),
|
||||
({"key": "ABC-34", "fields": valid, "properties": {"plan-item": {"L": "many"}}}, "item ABC-34's L 'many' is not a whole number from 1 to 4; ABC-34 holds it in its issue property plan-item"),
|
||||
({"key": "ABC-34", "fields": valid, "properties": None}, shape + ": AttributeError(\"'NoneType' object has no attribute 'get'\")"),
|
||||
):
|
||||
with self.subTest(raw=raw):
|
||||
self.jira.answers[("POST", SEARCH)] = {"issues": [raw]}
|
||||
|
||||
@@ -18,7 +18,7 @@ import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from test_env import isolated_env
|
||||
from test_env import assert_not_root, isolated_env
|
||||
from project_config.test_project_config import write_config
|
||||
|
||||
BIN = pathlib.Path(__file__).resolve().parents[1]
|
||||
@@ -753,8 +753,8 @@ class Cycles(unittest.TestCase):
|
||||
self.assertIn("past the noise", run.stdout)
|
||||
self.assertIn("past the noise", run.calls[1]["stdin"])
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root reads an unreadable file")
|
||||
def test_exits_1_when_the_transcript_cannot_be_read(self):
|
||||
assert_not_root(self)
|
||||
checkout = Checkout(self)
|
||||
run = checkout.run([worker(unreadable=True)])
|
||||
self.assertEqual((run.code, run.roles()), (1, ["worker"]))
|
||||
@@ -1000,8 +1000,8 @@ class Interrupt(unittest.TestCase):
|
||||
self.assertFalse(run.calls[2]["ctrl_c_ignored"])
|
||||
self.assertIn("[human] B", run.calls[3]["stdin"])
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root reads an unreadable file")
|
||||
def test_exits_1_when_the_transcript_cannot_be_read_after_the_interrupt(self):
|
||||
assert_not_root(self)
|
||||
checkout = Checkout(self)
|
||||
run = checkout.run([worker(say="A or B?"), judge(interrupt=True, evidence="A or B?", question="A or B?"), interrupt(type="B", unreadable=True)], terminal_input="/talk\n", before_typing=ANSWERING)
|
||||
self.assertEqual((run.code, run.roles()), (1, ["worker", "judge", "interrupt"]))
|
||||
@@ -1082,8 +1082,8 @@ class Models(unittest.TestCase):
|
||||
self.assertIn("no model catalog cached", run.stderr)
|
||||
self.assertEqual(argument(run.calls[0], "--model"), "1")
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root writes into a read-only directory")
|
||||
def test_exits_1_when_the_models_file_cannot_be_written(self):
|
||||
assert_not_root(self)
|
||||
checkout = Checkout(self)
|
||||
del checkout.env["LOOP_CLAUDE_JUDGE_MODEL"], checkout.env["LOOP_CLAUDE_WORKER_MODEL"]
|
||||
checkout.models_file().parent.mkdir(parents=True, mode=0o500)
|
||||
|
||||
@@ -19,6 +19,7 @@ import uuid
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from routing_figures import archive, state
|
||||
from test_env import assert_not_root
|
||||
from claude_code.output_limits import BASH_CEILING_CHARACTERS
|
||||
from routing_figures.calls import Call
|
||||
from loop_claude.project import checkout, model_choice, records
|
||||
@@ -519,8 +520,8 @@ Spent since 2026-09-21T14:13:20Z, in tokens of input, cache write 5m, cache writ
|
||||
[next_chunk] = set(self.archive.iterdir()) - {chunk}
|
||||
self.assertEqual(sorted(path.read_text() for path in (next_chunk / "session" / str(self.session.id)).glob("custom-title.json*")), ["third"])
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root reads an unreadable folder")
|
||||
def test_stops_on_a_session_folder_it_cannot_read_whole(self):
|
||||
assert_not_root(self)
|
||||
locked = self.paths.claude_code_transcripts / "-fake" / str(self.session.id) / "subagents"
|
||||
locked.mkdir(parents=True)
|
||||
locked.chmod(0)
|
||||
@@ -689,8 +690,8 @@ Spent since 2026-09-21T14:13:20Z, in tokens of input, cache write 5m, cache writ
|
||||
self.assertIn(f"\n{STAMP} Which one?\a\n", said.getvalue())
|
||||
self.assertNotIn("Use ... A.", said.getvalue())
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root writes into a read-only directory")
|
||||
def test_stops_keeping_the_transcript_when_the_finished_chunks_session_cannot_be_deleted(self):
|
||||
assert_not_root(self)
|
||||
folder = self.paths.claude_code_transcripts / "-fake" / str(self.session.id)
|
||||
(folder / "subagents").mkdir(parents=True)
|
||||
folder.chmod(0o500)
|
||||
@@ -967,8 +968,8 @@ class RoutingCheck(unittest.TestCase):
|
||||
stop, _ = self.check(FakeEffects(on_terminal_claude=[OSError(2, "No such file or directory")], git=[UNREAD] * 3))
|
||||
self.assertEqual(stop, Stop(1, f"could not start claude for the routing calls in {self.home / 'code' / 'claude-config'}, the setup's development clone: No such file or directory"))
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root writes into a read-only directory")
|
||||
def test_says_a_figure_it_cannot_write_and_goes_on(self):
|
||||
assert_not_root(self)
|
||||
self.chunks(5, 4)
|
||||
(self.root / "routing-figures.lock").touch()
|
||||
self.root.chmod(0o555)
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
import pathlib
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
@@ -22,9 +20,6 @@ Touches:
|
||||
More prose, with `bin/b.py` named.
|
||||
"""
|
||||
|
||||
needs_docker = unittest.skipIf(shutil.which("docker") is None or subprocess.run(["docker", "info"], capture_output=True, timeout=20).returncode != 0, "adf_codec runs in a container, which needs a docker daemon")
|
||||
|
||||
|
||||
def text(words: str, code: bool = False) -> dict:
|
||||
return {"type": "text", "text": words, **({"marks": [{"type": "code"}]} if code else {})}
|
||||
|
||||
@@ -90,15 +85,14 @@ class PredictedTest(unittest.TestCase):
|
||||
def test_a_longer_run_with_a_space_at_one_end_only_keeps_it(self) -> None:
|
||||
self.assertEqual(predicted("Touches:\n- `a.md`: `` x``, ``y ``, `` a ``\n"), {"a.md": (Part(" x"), Part("y "), Part("a"))})
|
||||
|
||||
@needs_docker
|
||||
def test_a_list_written_in_markdown_and_read_back_from_a_jira_description_reads_as_written(self) -> None:
|
||||
description = convert.markdown_to_adf(DETAIL)
|
||||
assert isinstance(description, dict)
|
||||
assert isinstance(description, dict), description
|
||||
self.assertEqual(predicted(convert.adf_to_markdown(description)), predicted(DETAIL))
|
||||
|
||||
@needs_docker
|
||||
def test_a_list_typed_in_jiras_editor_reads_as_its_files_and_parts(self) -> None:
|
||||
read = convert.adf_to_markdown(JIRA_TOUCHES)
|
||||
assert isinstance(read, str), read
|
||||
self.assertEqual(predicted(read), {
|
||||
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
|
||||
"a`b.md": (Part("## The `foo` tool", small=True), Part("`x`")),
|
||||
|
||||
@@ -476,7 +476,7 @@ def issue_of(raw: object) -> Issue | Failure:
|
||||
# The answer's nested fields are read as Jira documents them; one missing or of another type ends the read here, as a Failure, so no later step meets it.
|
||||
try:
|
||||
fields = raw["fields"]
|
||||
links = tuple(Link(link["inwardIssue"]["key"], link["id"]) for link in fields["issuelinks"] if "inwardIssue" in link and link["type"]["inward"] == "is blocked by")
|
||||
links = blocked_by_links(fields)
|
||||
held = raw.get("properties", {}).get(PROPERTY, {})
|
||||
summary, description, versions = fields["summary"].strip(), fields["description"], tuple(version["name"] for version in fields["fixVersions"])
|
||||
except (AttributeError, KeyError, TypeError) as failure:
|
||||
@@ -489,6 +489,11 @@ def issue_of(raw: object) -> Issue | Failure:
|
||||
return issue
|
||||
|
||||
|
||||
def blocked_by_links(fields: dict[str, typing.Any]) -> tuple[Link, ...]:
|
||||
"""The "is blocked by" links among an issue's `issuelinks` field. A field not in the shape Jira documents raises a KeyError or TypeError, which the caller turns into a Failure."""
|
||||
return tuple(Link(link["inwardIssue"]["key"], link["id"]) for link in fields["issuelinks"] if "inwardIssue" in link and link["type"]["inward"] == "is blocked by")
|
||||
|
||||
|
||||
def keys_of(answered: list[object]) -> set[object]:
|
||||
"""The key of each issue in the search's answer."""
|
||||
return {raw.get("key") for raw in answered if isinstance(raw, dict)}
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import dataclasses
|
||||
import decimal
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
import tempfile
|
||||
@@ -8,6 +7,7 @@ import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from test_env import assert_not_root
|
||||
from project_config.settings import DEFAULT_FLOOR, Epic, Finish, JiraScoring, ProjectConfig, SETTINGS
|
||||
from failure import Failure
|
||||
from record_store.stores import FileStore, goals_store, store as record_store
|
||||
@@ -136,8 +136,8 @@ class FilePlan(FilePlanContract):
|
||||
self.assertEqual(store.edit(id_, {}, "### Why\n"), Failure(split))
|
||||
self.assertEqual((self.folder / "todo.md").read_text(), before)
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root writes into a read-only directory")
|
||||
def test_a_file_it_cannot_write_fails_naming_it(self):
|
||||
assert_not_root(self)
|
||||
store = self.new_store()
|
||||
self.folder.chmod(0o555)
|
||||
self.addCleanup(self.folder.chmod, 0o755)
|
||||
|
||||
@@ -15,6 +15,7 @@ import unittest.mock
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from routing_figures import archive, state
|
||||
from test_env import assert_not_root, isolated_env
|
||||
from project_config.templates import BARE, Titles
|
||||
from branch_chunks.cut import BranchChunk
|
||||
from routing_figures.calls import Call, calls, totals
|
||||
@@ -25,7 +26,6 @@ from routing_figures.state import due
|
||||
from claude_code.entries import entry_from
|
||||
from failure import Failure
|
||||
from git_cli import git_repo
|
||||
from test_env import isolated_env
|
||||
from plan.todo_table import Item
|
||||
from transcript_archive import outcomes, write
|
||||
from model_routing.ladder_file import read_ladder, SHIPPED
|
||||
@@ -495,8 +495,8 @@ class Archive(unittest.TestCase):
|
||||
self.assertIsNone(state.mark_raised(self.root, [a], "2026-10-15T02:00:00Z"))
|
||||
self.assertEqual(state.raised(self.root), state.Raised("2026-10-15T01:00:00Z", frozenset({a})))
|
||||
|
||||
@unittest.skipIf(os.geteuid() == 0, "root writes into a read-only directory")
|
||||
def test_fails_when_it_cannot_keep_the_state(self):
|
||||
assert_not_root(self)
|
||||
self.root.chmod(0o555)
|
||||
self.addCleanup(self.root.chmod, 0o755)
|
||||
self.assertIsInstance(state.mark_measured(self.root, 40), Failure)
|
||||
|
||||
@@ -94,8 +94,7 @@ class RunHeavy(unittest.TestCase):
|
||||
|
||||
def test_a_docker_run_without_limits_gets_three_quarters_of_the_memory_split_across_the_slots(self):
|
||||
memory = read_memory()
|
||||
if memory is None:
|
||||
self.skipTest("no /proc/meminfo to read the share from")
|
||||
assert memory is not None, "this test needs MemTotal and MemAvailable from /proc/meminfo: run it on Linux"
|
||||
share = f"{memory.total * 3 // 4 // slot_count(usable_cpus()) // 1024}m"
|
||||
result = self.run_tool("docker", "run", "--rm", "img", "true", env=self.fake_docker())
|
||||
self.assertEqual((result.returncode, result.stdout), (0, f"run --memory {share} --memory-swap {share} --rm img true\n"))
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
import contextlib
|
||||
import importlib.util
|
||||
import io
|
||||
from unittest import mock
|
||||
import os
|
||||
@@ -14,10 +13,8 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
from run_tests import main
|
||||
|
||||
BIN = pathlib.Path(__file__).resolve().parents[1]
|
||||
# The suite runs under pytest, and `python3 -m unittest` may run it where pytest is not installed.
|
||||
HAS_PYTEST = importlib.util.find_spec("pytest") is not None
|
||||
HAS_XDIST = importlib.util.find_spec("xdist") is not None
|
||||
PYTEST_HERE = [sys.executable, "-m", "pytest", "-p", "no:cacheprovider"]
|
||||
# run-tests' own pytest command, without its worker count. uvx fetches pytest for it, so the Run tests need no pytest installed.
|
||||
PYTEST_PINNED = [*main.PYTEST[:main.PYTEST.index("-n")], "-p", "no:cacheprovider"]
|
||||
|
||||
|
||||
class PytestArgs(unittest.TestCase):
|
||||
@@ -109,7 +106,6 @@ class RunWithAStandIn(unittest.TestCase):
|
||||
self.assertEqual(err.getvalue(), "run-tests: cannot start /no/such/uvx: No such file or directory\n")
|
||||
|
||||
|
||||
@unittest.skipUnless(HAS_PYTEST, "needs pytest importable")
|
||||
class Run(unittest.TestCase):
|
||||
def run_in(self, folder: str, pytest: list[str], *args: str) -> tuple[int, str]:
|
||||
out = io.StringIO()
|
||||
@@ -127,8 +123,8 @@ class Run(unittest.TestCase):
|
||||
def test_a_passing_run_prints_the_summary_line_and_the_log_path(self):
|
||||
with tempfile.TemporaryDirectory() as folder:
|
||||
pathlib.Path(folder, "test_ok.py").write_text("def test_ok():\n\tprint('noise from a passing test')\n")
|
||||
code, output = self.run_in(folder, PYTEST_HERE, "-s", folder)
|
||||
self.assertEqual(code, 0)
|
||||
code, output = self.run_in(folder, PYTEST_PINNED, "-s", folder)
|
||||
self.assertEqual(code, 0, output)
|
||||
lines = output.rstrip("\n").splitlines()
|
||||
self.assertEqual(len(lines), 2, output)
|
||||
self.assertRegex(lines[0], r"^=+ 1 passed in .* =+$")
|
||||
@@ -136,10 +132,9 @@ class Run(unittest.TestCase):
|
||||
|
||||
def test_a_failing_run_prints_each_failing_test_with_its_error(self):
|
||||
# pytest-xdist drops the error from the short summary's lines, so the run takes it from the FAILURES section.
|
||||
workers = ["-n", "2"] if HAS_XDIST else []
|
||||
with tempfile.TemporaryDirectory() as folder:
|
||||
pathlib.Path(folder, "test_bad.py").write_text("def test_ok():\n\tpass\n\ndef test_bad():\n\tassert 1 == 2, 'one is not two'\n\ndef test_long():\n\traise ValueError('\\n'.join(map(str, range(30))))\n")
|
||||
code, output = self.run_in(folder, PYTEST_HERE, *workers, folder)
|
||||
code, output = self.run_in(folder, PYTEST_PINNED, "-n", "2", folder)
|
||||
self.assertEqual(code, 1)
|
||||
self.assertRegex(output, r"(?m)^_+ test_bad _+\nE +AssertionError: one is not two\n(E .*\n)*.*test_bad\.py:5: AssertionError$")
|
||||
self.assertRegex(output, r"(?m)^FAILED .*test_bad\.py::test_bad\b")
|
||||
@@ -158,7 +153,7 @@ class Run(unittest.TestCase):
|
||||
|
||||
def test_a_run_that_prints_no_summary_line_shows_the_logs_last_lines(self):
|
||||
with tempfile.TemporaryDirectory() as folder:
|
||||
code, output = self.run_in(folder, PYTEST_HERE, "--no-such-option", folder)
|
||||
code, output = self.run_in(folder, PYTEST_PINNED, "--no-such-option", folder)
|
||||
self.assertEqual(code, 1)
|
||||
self.assertIn("run-tests: pytest printed no summary line; the log ends:", output)
|
||||
self.assertIn("--no-such-option", output)
|
||||
|
||||
@@ -1,7 +1,13 @@
|
||||
import os
|
||||
import unittest
|
||||
|
||||
|
||||
# A git hook's GIT_DIR, the host's LOOP_CLAUDE_* or PYTHONPATH would point the program under test at the host's own state,
|
||||
# and the host's CLAUDE_CODE_SANDBOXED would hide whether loop-claude sets it.
|
||||
def isolated_env() -> dict[str, str]:
|
||||
return {name: value for name, value in os.environ.items() if not name.startswith(("GIT_", "LOOP_CLAUDE_", "PYTHON")) and name != "CLAUDE_CODE_SANDBOXED"}
|
||||
|
||||
|
||||
# Call it first in a test that takes a file's or a folder's permissions away.
|
||||
def assert_not_root(test: unittest.TestCase) -> None:
|
||||
test.assertNotEqual(os.geteuid(), 0, "root ignores file permissions, which this test checks: run the tests as a user other than root")
|
||||
|
||||
@@ -1,10 +1,15 @@
|
||||
#!/bin/sh
|
||||
# Runs the test suite on the committed HEAD as CI does: in a pinned Python container, as the caller's uid, so the tests that skip under root still run.
|
||||
# Runs the test suite on the committed HEAD as CI does: in a pinned Python container, as the caller's uid, since root ignores file permissions and the tests that check them would fail.
|
||||
# It is sh, not Python, since it runs on the CI runner's host, which needs only git and docker.
|
||||
# The repo goes in as a git bundle rather than a bind mount, so the script works whether the CI runner shares the docker daemon's filesystem or not.
|
||||
# The repo goes in as a git bundle rather than a bind mount, so the runner need not share the docker daemon's filesystem.
|
||||
# The adf-codec tests, which convert Jira descriptions, start a container of their own. So the test container holds a docker client and the daemon's socket.
|
||||
# The daemon mounts the socket from its own host, while stat reads its group on the runner: both need it at /var/run/docker.sock.
|
||||
set -eu
|
||||
cd "$(dirname "$0")"
|
||||
git bundle create - HEAD | docker run --rm -i --memory 4g --memory-swap 4g --user "$(id -u):$(id -g)" -e HOME=/tmp python:3.14.8 sh -euc '
|
||||
socket=/var/run/docker.sock
|
||||
# An untagged image, which docker image prune removes, since a cancelled run skips any cleanup.
|
||||
image=$(printf 'FROM docker:29.1.3-cli AS docker\nFROM python:3.14.8\nCOPY --from=docker /usr/local/bin/docker /usr/local/bin/docker\n' | docker build --quiet --memory 1g --memory-swap 1g -)
|
||||
git bundle create - HEAD | docker run --rm -i --memory 4g --memory-swap 4g --user "$(id -u):$(id -g)" --group-add "$(stat -c %g "$socket")" -v "$socket:$socket" -e HOME=/tmp "$image" sh -euc '
|
||||
cat >/tmp/head.bundle
|
||||
git -c init.defaultBranch=main -c advice.detachedHead=false clone --quiet /tmp/head.bundle /tmp/repo
|
||||
cd /tmp/repo
|
||||
|
||||
@@ -2759,3 +2759,13 @@ Read most (opens and searches):
|
||||
- `bin/loop_claude/cycle/prompts.py` 2
|
||||
- `bin/loop_claude/loop/main.py` 2
|
||||
- `ci.sh` 2
|
||||
|
||||
## Reading cost, chunk 26709555b08d, finished 2026-11-18T16:28:37Z
|
||||
|
||||
50266 new input tokens before the first commit.
|
||||
|
||||
Read most (opens and searches):
|
||||
|
||||
- `principles/technical-principles.md` 2
|
||||
- `README.md` 1
|
||||
- `agents/stability-reviewer.md` 1
|
||||
|
||||
@@ -46,6 +46,7 @@
|
||||
- Assert the outcome — returned values, stored state, emitted output — not how the code reached it. Use real collaborators or fakes; mock only slow, nondeterministic or external edges. BANNED: asserting which internal function ran, or scanning the source with `ast` or a regex. GOOD: `assertEqual(saved_row, {...})` against a fake store; a fake clock.
|
||||
- Pin wording only where the wording is the contract: a message a consumer parses, a published format. For prompts, help and error text, assert the facts the text must carry — an item ID, a model argument, an error code — not the sentence. BANNED: `assertIn("<a 600-character prompt sentence>", prompt)`. GOOD: `assertIn("model opus, effort high", prompt)`.
|
||||
- One behaviour per test, named for it, tested once, at the lowest level that reproduces it. No loops or branches in a test body; parametrize the cases.
|
||||
- A test doesn't decide at run time whether to check anything: no conditional skip, early return, or catch around its assertions. A test that needs a state creates it, or fails and names what is missing. BANNED: `test.skip(created.every((count) => count === 0))` after the payroll run under test, since a broken payroll also creates zero rows. GOOD: before running the payroll, check each precondition and fail naming the one that is missing; after it, `expect(created).toEqual([1, 2, 1])`.
|
||||
- Every escaped bug becomes a test that fails without its fix.
|
||||
- Write no test that no real bug could fail: a constant's value, a list's length, the framework's own behaviour.
|
||||
- A test neither sleeps nor asserts on the wall clock, and seeds any randomness.
|
||||
|
||||
@@ -6,20 +6,18 @@
|
||||
|
||||
`Bar = 0.1`
|
||||
|
||||
`Next ID = 428`
|
||||
`Next ID = 439`
|
||||
|
||||
## Items
|
||||
|
||||
| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |
|
||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|
||||
| 426 | 0.12.0 | | | **Read each epic issue's scores, its blockers and whether the loop filed it through `EpicStore`, from both backends.** | 2 | 2 | 2 | 4 | 3 | 1 by 5 | 1.9 |
|
||||
| 427 | 0.12.0 | 426 | | **Re-rank Jira's backlog to match an epic's ranking, moving only the issues the loop filed, so people's issues keep their rank.** | 3 | 2 | 3 | 6 | 3 | 1 by 5 | 1.9 |
|
||||
| 427 | 0.12.0 | | | **Re-rank Jira's backlog to match an epic's ranking, moving only the issues the loop filed, so people's issues keep their rank.** | 3 | 2 | 3 | 6 | 3 | 1 by 5 | 1.9 |
|
||||
| 410 | 0.12.0 | 427 | | **Run `do-epic <EPIC-KEY>`: one tmux session per epic, a window per chunk, up to the epic's cap of running chunks and each repo's `parallel-chunks`, and never in a repo a loop-claude is running chunks in.** | 3 | 2 | 3 | 6 | 6 | 1 by 5 | 0.8 |
|
||||
| 416 | 0.12.0 | 410 | | **Finish an epic's repo item with a bullet under its repo's `CHANGELOG.md` → `## Unreleased`, or with none where the repo's plan is in Jira.** | 1 | 1 | 1 | 1 | 2 | 1 by 5 | 2.1 |
|
||||
| 413 | 0.12.0 | 410 | | **File a finding about an epic goal in the epic and one about a repo goal by that repo's rules, ask the human where unsure which, and give the judge the epic's records beside the repo's.** | 3 | 2 | 3 | 6 | 4 | 1 by 5 | 1.6 |
|
||||
| 415 | 0.12.0 | 410, 413 | | **Finish an epic: run release-review passes on each repo it changed, work what they file, have the human confirm each goal, post a summary comment, and close the epic in Jira last.** | 3 | 2 | 3 | 6 | 5 | 1 by 5 | 1.2 |
|
||||
| 418 | 0.12.0 | 415 | | **Describe do-epic in `README.md`'s tools and setup, with its machine settings and `repo-rule.md`.** | 1 | 2 | 1 | 2 | 2 | 1 by 5 | 2.1 |
|
||||
| 400 | 0.12.0 | | | **Forbid a test that decides at run time whether to check anything in `principles/technical-principles.md`, and point stability-reviewer's Tests checks at it.** | 1 | 2 | 3 | 4 | 2 | 1.1 by 5 | 2.0 |
|
||||
| 420 | 0.12.0 | | | **End a worker that printed its final result and lingers, by killing the background shells it left, after a few minutes, and print each kill with its evidence on loop-claude's terminal.** | 2 | 2 | 2 | 4 | 3 | 1.5 by 6 | 2.0 |
|
||||
| 409 | 0.12.0 | | | **Split an epic item that changes several repos into one Jira sub-task per repo, each labelled for its repo, with the parent tracking the whole change, when do-epic plans the item.** | 2 | 2 | 3 | 5 | 3 | 1 by 5 | 1.9 |
|
||||
| 411 | 0.12.0 | 410 | | **Park a chunk whose PR waits on a long gate, keeping its worktree, PR and session in a state file that survives a reboot, and resume its session when the gate passes or a reviewer comments.** | 3 | 2 | 3 | 6 | 5 | 1 by 5 | 1.2 |
|
||||
@@ -28,6 +26,7 @@
|
||||
| 417 | 0.12.0 | 410 | | **Run do-epic end to end against a sandbox epic on a real Jira site with a command of its own, outside `run-tests`.** | 2 | 1 | 1 | 2 | 3 | 1 by 5 | 1.9 |
|
||||
| 421 | 0.12.0 | | | **Refuse in rule-hook a Bash or Monitor wait that has no end: a loop without a time or count cap, and a `pgrep -f` or `pkill -f` whose pattern the same command line contains.** | 2 | 2 | 3 | 5 | 3 | 1.5 by 4 | 1.3 |
|
||||
| 316 | 0.12.0 | | | **Launch comprehension seats as an agent type of their own under `agents/`, without `CLAUDE.md` and the skill and agent listings a general-purpose subagent carries.** | 2 | 2 | 2 | 4 | 3 | 1.4 by 3 | 1.0 |
|
||||
| 429 | 0.12.0 | | | **Bring nine lessons from a client setup into the principles, the reviewers, larv-review and the project config, and rank a deterministic tool first where an outside reviewer's finding changes the setup.** | 4 | 2 | 3 | 7 | 7 | 1.1 by 5, 1.6 by 5 | 0.9 |
|
||||
| 310 | 0.12.0 | | | **Compact a waiting worker's session shortly before its prompt cache expires, only when the human has not answered an interrupt by then.** | 3 | 2 | 3 | 6 | 4 | 1.4 by 3 | 0.9 |
|
||||
| 422 | 0.12.0 | 420 | | **Check every 5 minutes whether a tmux window of the loop looks stuck by other signs than a lingering worker, investigate it with a headless claude, and kill only the process the investigation names.** | 3 | 2 | 3 | 6 | 5 | 1.5 by 4 | 0.8 |
|
||||
| 365 | 0.13.0 | | | **Have `score-outcomes` read the finished and dropped items of a plan outside the checkout, from the project repo's history or from Jira's issue changelogs.** | 3 | 2 | 2 | 5 | 4 | 1.6 by 2, 1.1 by 2 | 1.2 |
|
||||
@@ -82,18 +81,6 @@
|
||||
|
||||
## Details
|
||||
|
||||
### 426. Read each epic issue's scores, its blockers and whether the loop filed it through `EpicStore`, from both backends.
|
||||
|
||||
Today `EpicIssue` holds none of the three, so do-epic cannot score or order an epic's items (item 408) or tell a person's issue from its own (item 427). The Jira backend reads them as `plan_store/jira_epic.py` does: the `plan-item` issue property, its `Filed by` key, and the "is blocked by" links. The contract tests in `contract.py` cover both backends.
|
||||
|
||||
Touches:
|
||||
|
||||
- `bin/do_epic/backend/protocol.py`: `EpicIssue` (small)
|
||||
- `bin/do_epic/backend/fake.py`
|
||||
- `bin/do_epic/backend/jira.py`: `FIELDS`, `JiraEpic.found`
|
||||
- `bin/do_epic/backend/contract.py`
|
||||
- `bin/do_epic/backend/test_jira.py`
|
||||
|
||||
### 427. Re-rank Jira's backlog to match an epic's ranking, moving only the issues the loop filed, so people's issues keep their rank.
|
||||
|
||||
Split from item 408 (`docs/decisions.md` → `do-epic: drives one Jira epic …`). `EpicStore` gains a rank call, in both backends and the contract tests. Lift `JiraPlan.rank_refusal` to a module function both stores call. Walk the target order: where the issue at a position isn't the target's, rank the target's just before it; the slots people's issues hold stay theirs. A rank Jira refuses stops the walk and is reported, since a wrongly ranked team backlog takes hours to restore.
|
||||
@@ -163,19 +150,6 @@ Touches:
|
||||
|
||||
- `README.md`: `## Tools`, `### Set up a project` (small)
|
||||
|
||||
### 400. Forbid a test that decides at run time whether to check anything in `principles/technical-principles.md`, and point stability-reviewer's Tests checks at it.
|
||||
|
||||
Today the rule is only implied, by "fails when that behaviour breaks" and "states what it needs and gets it". Proposed bullet under the tests principle: "A test doesn't decide at run time whether to check anything: no conditional skip, early return, or catch around its assertions. A test that needs a state creates it, or fails and names what is missing. BANNED: `test.skip(created.every((count) => count === 0))`, since a broken payroll also creates zero rows. GOOD: check the precondition before the action, failing with its cause, then `expect(created).toEqual([1, 2, 1])`."
|
||||
|
||||
Add one line to section 11 of `agents/stability-reviewer.md` that points at the bullet.
|
||||
|
||||
Source: a client project's pull request, where a fix hid a regression behind a conditional skip.
|
||||
|
||||
Touches:
|
||||
|
||||
- `principles/technical-principles.md`
|
||||
- `agents/stability-reviewer.md`: `### 11. Tests` (small)
|
||||
|
||||
### 420. End a worker that printed its final result and lingers, by killing the background shells it left, after a few minutes, and print each kill with its evidence on loop-claude's terminal.
|
||||
|
||||
On 2026-11-18 the worker of the item 402 chunk merged its pull request at about 11:47, printed its summary and then waited 95 minutes: it had started `until [ -s /tmp/merge-402.log ] && ! pgrep -f "chunk-pr merg"; do sleep 15; done` in the background, and `pgrep -f` matched the loop's own command line, so the condition never held. Its `claude -p` stayed alive ("Waiting for background work to finish"), `loop-claude` waited for it to exit, and the window's slot started no new chunk until the human found it and killed the shell.
|
||||
@@ -275,6 +249,33 @@ Touches:
|
||||
- `bin/rule_hook/test_rule_hook.py`: `ReviewerRung`
|
||||
- `bin/larv_review/test_scoring_setup.py`
|
||||
|
||||
### 429. Bring nine lessons from a client setup into the principles, the reviewers, larv-review and the project config, and rank a deterministic tool first where an outside reviewer's finding changes the setup.
|
||||
|
||||
Lessons from running this setup in a client's repo, shipped as one chunk. Each part names the gap it closes; none names the client, its code or its reviewers' text.
|
||||
|
||||
1. **Open the pull request after our own review, where CI runs on pushed branches.** Today larv-review §2 opens a draft first. A forge's auto-reviewer reviews drafts and human reviewers see them, so in a client's chunk about six outside findings landed that our passes would have caught. Nothing in larv-review needs a pull request before the gate: `reviewer-header` prints `PR: none open at the pushed head`, and round counts read commit titles. Push early so CI runs; run `chunk-pr open` once every §3 pass is done and §2's tests, static analysis and mutation tests pass; mark it ready at once. Where CI runs only on pull requests, keep the draft-first order. Decide which from the repo's CI config, and say in the summary which order the chunk took.
|
||||
2. **Rules for tests on a shared environment**, in the "Tests and tooling" bullet under "Compose, do not entangle", one BANNED/GOOD pair each: assert only on records the test created and can name, never on a count or the first row; never change state the test doesn't own; pass in any order and beside a second copy of itself running at the same time; a helper registers its teardown before it creates anything, keyed by a value it made itself, and the teardown deletes only what it can name; a helper that saves checks what was saved, never the status code alone.
|
||||
3. **"Make invalid states unrepresentable" gets an example about function inputs.** Its only example is a database time type, so in a client's chunk nobody connected it to a test helper that validated its caller's input, over four review rounds. BANNED: a helper that takes a token and a message, and checks that the message holds the token. GOOD: the helper makes the token and builds the message. Add: "When a review finds a second edge case in a check, change the signature so the input can't occur."
|
||||
4. **stability-reviewer checks a change that stores a value differently**, in "Data Integrity & Persistence": where a change escapes, converts or grows a stored value, the longest value it can now write must fit the column, and every search, filter or comparison on the column must still find what users type. In a client's chunk, escaping text into a TEXT column lowered its overflow limit fivefold, and a LIKE search stopped matching apostrophes; stability missed both.
|
||||
5. **A `conventions` setting in the project config**: an optional list of paths, in the other settings' path syntax, such as `checkout:CONVENTIONS.md`. `reviewer-header` prints them, every reviewer reads them beside the principles and standards, and the team's rule wins where they conflict. A missing file fails as an empty principles folder does. Today a team's conventions reach reviewers only by hand.
|
||||
6. **larv-review §2 files an item to add a mutation tool** when `mutate-changes` prints its line naming changed files no tool covers, or refreshes the item an earlier chunk filed: the language's mutation tool, pinned to a version that supports the project's language version. In a client's PHP repo without one, three findings were surviving mutants a tool would have reported before review.
|
||||
7. **The principle "Never mock a service your own team runs."** Test the seam to it against its real build, in a harness that runs the real stack; mock only a third party that can't be run locally in a reasonable way. The rule binds the test that covers the seam: a unit test of the caller's own logic may still use a fake, as "Use real collaborators or fakes" allows.
|
||||
8. **The principle "Don't loosen a type when refactoring"**, under "Validate data and build DTOs as early as possible.", with one BANNED/GOOD pair: a function that returned a concrete type keeps returning it when its implementation changes, never `object`, `array`, `mixed` or `any`; introduce a DTO or value object instead.
|
||||
9. **Reflect on every outside reviewer's finding, deterministic tools first.** `CLAUDE.md` → "Working loop" → "Change the setup for each reasonable fix an outside reviewer asked for on a PR" already asks why our review missed it, but ranks reviewer agents and larv-review with the hooks and tools, and covers only fixes. Make it cover every finding an outside reviewer raises, and rank the places: 1. a deterministic tool that would have caught it, such as a rule-hook rule, a gate check, a linter setting or `mutate-changes`; 2. the technical principles or review standards; 3. anything else: the reviewers' agents, `larv-review`'s text, or the project's own settings, principles folder or `AGENTS.md`.
|
||||
|
||||
Touches:
|
||||
- `CLAUDE.md`: `## Working loop` (small)
|
||||
- `skills/larv-review/SKILL.md`: `## 2. Ship the branch`, `## 4. Gate`, `### Principles` (small)
|
||||
- `bin/chunk_pr/main.py`: `opened` (small)
|
||||
- `bin/chunk_pr/test_chunk_pr.py`
|
||||
- `principles/technical-principles.md`: `Compose, do not entangle`, `Make invalid states unrepresentable.`, `Validate data and build DTOs as early as possible.`, `Most, if not all, code should have automated tests, and each test earns its keep.`
|
||||
- `agents/stability-reviewer.md`: `### 7. Data Integrity & Persistence` (small), `### 11. Tests` (small)
|
||||
- `bin/project_config/settings.py`: `SETTINGS`
|
||||
- `bin/project_config/test_project_config.py`
|
||||
- `bin/larv_review/reviewer_header.py`
|
||||
- `bin/larv_review/test_larv_review.py`
|
||||
- `README.md`: `## Install` (small)
|
||||
|
||||
### 310. Compact a waiting worker's session shortly before its prompt cache expires, only when the human has not answered an interrupt by then.
|
||||
|
||||
281 worker resumes after the 1-hour cache expired rewrote a whole context, $379 of the $9,154 measured from 2026-09-30 to 2026-11-11 (4.1%). A compaction while the cache is warm reads the context at a twentieth of the input price and leaves about 20k tokens to rewrite later.
|
||||
|
||||
Reference in New Issue
Block a user